def test_dump(): directory = tempfile.mkdtemp(prefix = "openfisca_") simulation = Simulation(tax_benefit_system = tax_benefit_system, simulation_json = couple) calculated_value = simulation.calculate('disposable_income', '2018-01') dump_simulation(simulation, directory) simulation_2 = restore_simulation(directory, tax_benefit_system) # Check entities structure have been restored assert_array_equal(simulation.person.ids, simulation_2.person.ids) assert_array_equal(simulation.person.count, simulation_2.person.count) assert_array_equal(simulation.household.ids, simulation_2.household.ids) assert_array_equal(simulation.household.count, simulation_2.household.count) assert_array_equal(simulation.household.members_position, simulation_2.household.members_position) assert_array_equal(simulation.household.members_entity_id, simulation_2.household.members_entity_id) assert_array_equal(simulation.household.members_legacy_role, simulation_2.household.members_legacy_role) 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 assert_array_equal(cached_value, calculated_value) shutil.rmtree(directory)
def calculate(): tax_benefit_system = data['tax_benefit_system'] request.on_json_loading_failed = handle_invalid_json input_data = request.get_json() try: simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=input_data) except SituationParsingError as e: abort(make_response(jsonify(e.error), e.code or 400)) requested_computations = dpath.util.search(input_data, '*/*/*/*', afilter=lambda t: t is None, yielded=True) for computation in requested_computations: path = computation[0] entity_plural, entity_id, variable_name, period = path.split('/') result = simulation.calculate(variable_name, period).tolist() entity = simulation.get_entity(plural=entity_plural) entity_index = entity.ids.index(entity_id) variable = tax_benefit_system.get_variable(variable_name) if variable.value_type == Enum: entity_result = result[entity_index].name else: entity_result = result[entity_index] dpath.util.set(input_data, path, entity_result) return jsonify(input_data)
def trace(tax_benefit_system, input_data): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=input_data, trace=True) requested_computations = dpath.util.search(input_data, '*/*/*/*', afilter=lambda t: t is None, yielded=True) for computation in requested_computations: path = computation[0] entity_plural, entity_id, variable_name, period = path.split('/') simulation.calculate(variable_name, period) trace = deepcopy(simulation.tracer.trace) for vector_key, vector_trace in trace.items(): value = vector_trace['value'].tolist() if isinstance(value[0], Enum): value = [item.name for item in value] if isinstance(value[0], bytes): value = [to_unicode(item) for item in value] vector_trace['value'] = value return { "trace": trace, "entitiesDescription": {entity.plural: entity.ids for entity in simulation.entities.values()}, "requestedCalculations": list(simulation.tracer.requested_calculations) }
def calculate(tax_benefit_system, input_data): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=input_data) requested_computations = dpath.util.search(input_data, '*/*/*/*', afilter=lambda t: t is None, yielded=True) computation_results = {} for computation in requested_computations: path = computation[0] entity_plural, entity_id, variable_name, period = path.split('/') variable = tax_benefit_system.get_variable(variable_name) result = simulation.calculate(variable_name, period) entity = simulation.get_entity(plural=entity_plural) entity_index = entity.ids.index(entity_id) if variable.value_type == Enum: entity_result = result.decode()[entity_index].name elif variable.value_type == float: entity_result = float( str(result[entity_index]) ) # To turn the float32 into a regular float without adding confusing extra decimals. There must be a better way. elif variable.value_type == str: entity_result = to_unicode( result[entity_index]) # From bytes to unicode else: entity_result = result.tolist()[entity_index] dpath.util.new(computation_results, path, entity_result) dpath.merge(input_data, computation_results) return input_data
def test_get_memory_usage(): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=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 trace(): tax_benefit_system = data['tax_benefit_system'] request.on_json_loading_failed = handle_invalid_json input_data = request.get_json() try: simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=input_data, trace=True) except SituationParsingError as e: abort(make_response(jsonify(e.error), e.code or 400)) requested_computations = dpath.util.search(input_data, '*/*/*/*', afilter=lambda t: t is None, yielded=True) for computation in requested_computations: path = computation[0] entity_plural, entity_id, variable_name, period = path.split('/') simulation.calculate(variable_name, period).tolist() return jsonify({ "trace": simulation.tracer.trace, "entitiesDescription": { entity.plural: entity.ids for entity in simulation.entities.itervalues() }, "requestedCalculations": list(simulation.tracer.requested_calculations) })
def test_clone(): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json={ "persons": { "bill": { "salary": { "2017-01": 3000 } }, }, "households": { "household": { "parents": ["bill"] } } }) simulation_clone = simulation.clone() assert simulation != simulation_clone for entity_id, entity in simulation.entities.items(): assert entity != simulation_clone.entities[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.entity == simulation_clone.person
def test_calculate_output_divide(): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=single) simulation.set_input('variable_with_calculate_output_divide', 2017, [12000]) assert_near( simulation.calculate_output('variable_with_calculate_output_divide', '2017-06'), 1000)
def calculate(): tax_benefit_system = data['tax_benefit_system'] request.on_json_loading_failed = handle_invalid_json input_data = request.get_json() try: simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=input_data) except SituationParsingError as e: abort(make_response(jsonify(e.error), e.code or 400)) except UnicodeEncodeError as e: abort( make_response( jsonify({ "error": "'" + e[1] + "' is not a valid ASCII value." }), 400)) requested_computations = dpath.util.search(input_data, '*/*/*/*', afilter=lambda t: t is None, yielded=True) results = {} try: for computation in requested_computations: path = computation[0] entity_plural, entity_id, variable_name, period = path.split( '/') variable = tax_benefit_system.get_variable(variable_name) result = simulation.calculate(variable_name, period) entity = simulation.get_entity(plural=entity_plural) entity_index = entity.ids.index(entity_id) if variable.value_type == Enum: entity_result = result.decode()[entity_index].name elif variable.value_type == float: entity_result = float( str(result[entity_index]) ) # To turn the float32 into a regular float without adding confusing extra decimals. There must be a better way. elif variable.value_type == str: entity_result = to_unicode( result[entity_index]) # From bytes to unicode else: entity_result = result.tolist()[entity_index] dpath.util.new(results, path, entity_result) except UnicodeEncodeError as e: abort( make_response( jsonify({ "error": "'" + e[1] + "' is not a valid ASCII value." }), 400)) dpath.util.merge(input_data, results) return jsonify(input_data)
def test_set_input_enum(): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=couple) status_occupancy = np.asarray(['owner']) period = make_period('2017-12') HousingOccupancyStatus = tax_benefit_system.get_variable( 'housing_occupancy_status').possible_values simulation.household.get_holder('housing_occupancy_status').set_input( period, status_occupancy) result = simulation.calculate('housing_occupancy_status', period) assert_equal(result, HousingOccupancyStatus.owner)
def test_entity_variables_with_constructor(): simulation_json = { "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 = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=simulation_json) household = simulation.household assert_near(household('rent', "2017-06"), [800, 600])
def test_entity_structure_with_constructor(): simulation_json = { "persons": { "bill": {}, "bob": {}, "claudia": {}, "janet": {}, "tom": {}, }, "households": { "first_household": { "parents": ['bill', 'bob'], "children": ['janet', 'tom'] }, "second_household": { "parents": ["claudia"] } } } simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=simulation_json) household = simulation.household assert_near(household.members_entity_id, [0, 0, 1, 0, 0]) assert ((household.members_role == [ FIRST_PARENT, SECOND_PARENT, FIRST_PARENT, CHILD, CHILD ]).all()) assert_near(household.members_legacy_role, [0, 1, 0, 2, 3]) assert_near(household.members_position, [0, 1, 0, 2, 3])
def restore_simulation(directory, tax_benefit_system, **kwargs): """ Restore simulation from directory """ simulation = Simulation(tax_benefit_system, tax_benefit_system.instantiate_entities()) entities_dump_dir = os.path.join(directory, "__entities__") for population in simulation.populations.values(): if population.entity.is_person: continue person_count = _restore_entity(population, entities_dump_dir) for population in simulation.populations.values(): if not population.entity.is_person: continue _restore_entity(population, entities_dump_dir) population.count = person_count variables_to_restore = (variable for variable in os.listdir(directory) if variable != "__entities__") for variable in variables_to_restore: _restore_holder(simulation, variable, directory) return simulation
def test_get_formula(): simulation = Simulation(tax_benefit_system = tax_benefit_system, simulation_json = couple) disposable_income_formula = tax_benefit_system.get_variable('disposable_income').get_formula() person = simulation.person disposable_income = person('disposable_income', '2017-01') disposable_income_2 = disposable_income_formula(person, '2017-01', None) # No need for parameters here assert_near(disposable_income, disposable_income_2)
def build_from_entities(self, tax_benefit_system, input_dict, default_period=None, **kwargs): """ Build a simulation from a Python dict ``input_dict`` fully specifying entities. Examples: >>> simulation_builder.build_from_entities({ 'persons': {'Javier': { 'salary': {'2018-11': 2000}}}, 'households': {'household': {'parents': ['Javier']}} }) """ simulation = kwargs.pop( 'simulation', None ) # Only for backward compatibility with previous Simulation constructor if simulation is None: simulation = Simulation(tax_benefit_system, **kwargs) check_type(input_dict, dict, ['error']) unexpected_entities = [ entity for entity in input_dict if entity not in tax_benefit_system.entities_plural() ] if unexpected_entities: unexpected_entity = unexpected_entities[0] raise SituationParsingError([unexpected_entity], ''.join([ "Some entities in the situation are not defined in the loaded tax and benefit system.", "These entities are not found: {0}.", "The defined entities are: {1}." ]).format(', '.join(unexpected_entities), ', '.join(tax_benefit_system.entities_plural()))) persons_json = input_dict.get(tax_benefit_system.person_entity.plural, None) if not persons_json: raise SituationParsingError([ tax_benefit_system.person_entity.plural ], 'No {0} found. At least one {0} must be defined to run a simulation.' .format(tax_benefit_system. person_entity.key)) self.hydrate_entity(simulation.persons, persons_json, default_period=default_period) for entity_class in tax_benefit_system.group_entities: entities_json = input_dict.get(entity_class.plural) self.hydrate_entity(simulation.entities[entity_class.key], entities_json, default_period=default_period) return simulation
def test_calculate_output_add(): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=single) simulation.set_input('variable_with_calculate_output_add', '2017-01', [10]) simulation.set_input('variable_with_calculate_output_add', '2017-05', [20]) simulation.set_input('variable_with_calculate_output_add', '2017-12', [70]) assert_near( simulation.calculate_output('variable_with_calculate_output_add', 2017), 100)
def run_situation(reform_name, reform, situation_json, calculs): with open(situation_json) as json_data: json_str = json_data.read() situation = json.loads(json_str) results = {"Situation": situation_json, "Legislation": reform_name} # Initialisez la simulation (rencontre des entités avec la legislation) simulation = Simulation(tax_benefit_system=reform, simulation_json=situation) # Demandez l'ensemble des calculs for calcul, period in calculs.iteritems(): results try: results[calcul] = simulation.calculate(calcul, period)[0] print('. ' + calcul) except ParameterNotFound as e: print 'x ' + calcul print e.message + os.linesep return results
def run_situation(reform_name, reform, situation_json, calculs): with open(situation_json) as json_data: json_str = json_data.read() situation = json.loads(json_str) results = {"Situation": situation_json, "Legislation": reform_name} # Initialisez la simulation (rencontre des entités avec la legislation) simulation = Simulation(tax_benefit_system=reform, simulation_json=situation) # Demandez l'ensemble des calculs for calcul, period in calculs.iteritems(): results try: results[calcul] = simulation.calculate(calcul, period)[0] print('. ' + calcul) except ParameterNotFound as e: print 'x ' + calcul print e.message + os.linesep return results
def trace(): tax_benefit_system = data['tax_benefit_system'] request.on_json_loading_failed = handle_invalid_json input_data = request.get_json() try: simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=input_data, trace=True) except SituationParsingError as e: abort(make_response(jsonify(e.error), e.code or 400)) requested_computations = dpath.util.search(input_data, '*/*/*/*', afilter=lambda t: t is None, yielded=True) for computation in requested_computations: path = computation[0] entity_plural, entity_id, variable_name, period = path.split('/') simulation.calculate(variable_name, period) trace = deepcopy(simulation.tracer.trace) for vector_key, vector_trace in trace.items(): value = vector_trace['value'].tolist() if isinstance(value[0], Enum): value = [item.name for item in value] if isinstance(value[0], bytes): value = [to_unicode(item) for item in value] vector_trace['value'] = value return jsonify({ "trace": trace, "entitiesDescription": { entity.plural: entity.ids for entity in simulation.entities.values() }, "requestedCalculations": list(simulation.tracer.requested_calculations) })
def build_default_simulation(self, tax_benefit_system, count = 1): """ Build a simulation where: - There are ``count`` persons - There are ``count`` instances of each group entity, containing one person - Every person has, in each entity, the first role """ simulation = Simulation(tax_benefit_system, tax_benefit_system.instantiate_entities()) for population in simulation.populations.values(): population.count = count population.ids = np.array(range(count)) if not population.entity.is_person: population.members_entity_id = population.ids # Each person is its own group entity return simulation
def restore_simulation(directory, tax_benefit_system, **kwargs): """ Restore simulation from directory """ simulation = Simulation(tax_benefit_system, **kwargs) entities_dump_dir = os.path.join(directory, "__entities__") for entity in simulation.entities.values(): _restore_entity(entity, entities_dump_dir) variables_to_restore = (variable for variable in os.listdir(directory) if variable != "__entities__") for variable in variables_to_restore: _restore_holder(simulation, variable, directory) return simulation
def build_default_simulation(self, tax_benefit_system, count=1, **kwargs): """ Build a simulation where: - There are ``count`` persons - There are ``count`` instances of each group entity, containing one person - Every person has, in each entity, the first role """ simulation = Simulation(tax_benefit_system, **kwargs) for entity in simulation.entities.values(): entity.count = count entity.ids = np.array(range(count)) if not entity.is_person: entity.members_entity_id = entity.ids # Each person is its own group entity entity.members_role = entity.filled_array( entity.flattened_roles[0]) return simulation
def test_set_input_with_constructor(): simulation_json = { "persons": { "bill": { "salary": { "2017": 24000, "2017-11": 2000, "2017-12": 2000 } }, "bob": { "salary": { "2017": 30000, "2017-11": 0, "2017-12": 0 } }, "claudia": { "salary": { "2017": 24000, "2017-11": 4000, "2017-12": 4000, } }, "janet": {}, "tom": {}, }, "households": { "first_household": { "parents": ['bill', 'bob'], "children": ['janet', 'tom'], }, "second_household": { "parents": ["claudia"], } } } simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=simulation_json) person = simulation.person assert_near(person('salary', "2017-12"), [2000, 0, 4000, 0, 0]) assert_near(person('salary', "2017-10"), [2000, 3000, 1600, 0, 0])
def test_finalize_households(tax_benefit_system): simulation = Simulation(tax_benefit_system, tax_benefit_system.instantiate_entities()) simulation_builder = SimulationBuilder() simulation_builder.add_group_entity( 'persons', ['Alicia', 'Javier', 'Sarah', 'Tom'], simulation.household.entity, { 'Household_1': { 'parents': ['Alicia', 'Javier'] }, 'Household_2': { 'parents': ['Tom'], 'children': ['Sarah'] }, }) simulation_builder.finalize_variables_init(simulation.household) tools.assert_near(simulation.household.members_entity_id, [0, 0, 1, 1]) tools.assert_near(simulation.persons.has_role(entities.Household.PARENT), [True, True, False, True])
def make_simulation(tax_benefit_system, nb_persons, nb_groups, **kwargs): """ Generate a simulation containing nb_persons persons spread in nb_groups groups. Example: >>> from openfisca_core.scripts.simulation_generator import make_simulation >>> from openfisca_france import CountryTaxBenefitSystem >>> tbs = CountryTaxBenefitSystem() >>> simulation = make_simulation(tbs, 400, 100) # Create a simulation with 400 persons, spread among 100 families >>> simulation.calculate('revenu_disponible', 2017) """ simulation = Simulation(tax_benefit_system=tax_benefit_system, **kwargs) simulation.persons.ids = np.arange(nb_persons) simulation.persons.count = nb_persons adults = [0] + sorted(random.sample(range(1, nb_persons), nb_groups - 1)) members_entity_id = np.empty(nb_persons, dtype=int) # A legacy role is an index that every person within an entity has. For instance, the 'demandeur' has legacy role 0, the 'conjoint' 1, the first 'child' 2, the second 3, etc. members_legacy_role = np.empty(nb_persons, dtype=int) id_group = -1 for id_person in range(nb_persons): if id_person in adults: id_group += 1 legacy_role = 0 else: legacy_role = 2 if legacy_role == 0 else legacy_role + 1 members_legacy_role[id_person] = legacy_role members_entity_id[id_person] = id_group for entity in simulation.entities.values(): if not entity.is_person: entity.members_entity_id = members_entity_id entity.members_legacy_role = members_legacy_role entity.count = nb_groups entity.members_role = np.where(members_legacy_role == 0, entity.flattened_roles[0], entity.flattened_roles[-1]) return simulation
def test_projectors_methods(): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=couple) household = simulation.household person = simulation.person projected_vector = household.first_parent.has_role(Household.FIRST_PARENT) assert (len(projected_vector) == 1) # Must be of a household dimension salary_i = person.household.members('salary', '2017-01') assert (len(person.household.sum(salary_i)) == 2 ) # Must be of a person dimension assert (len(person.household.max(salary_i)) == 2 ) # Must be of a person dimension assert (len(person.household.min(salary_i)) == 2 ) # Must be of a person dimension assert (len(person.household.all(salary_i)) == 2 ) # Must be of a person dimension assert (len(person.household.any(salary_i)) == 2 ) # Must be of a person dimension assert (len(household.first_parent.get_rank(household, salary_i)) == 1 ) # Must be of a person dimension
'af': allMonths, 'af_nbenf': allMonths, 'af_taux_modulation': allMonths, 'prestations_familiales_base_ressources': allMonths, } calculs = { 'af': allMonths, } import experiment_af import situations situation = utils.merge(utils.prefix('7618153', situations.situation_7618153), utils.prefix('6771069', situations.situation_6771069)) simulation_actuelle = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=situation) checkPeriod = "2018-07" for calcul, periods in calculs.iteritems(): ids = simulation_actuelle.get_variable_entity(calcul).ids for period in periods: data = simulation_actuelle.calculate(calcul, period) result = dict(zip(ids, data)) for mid, value in result.iteritems(): print(mid, value, value * 0.995) # source = situation["familles"][mid]["af"][checkPeriod] # if abs(source - value)>1: # print (mid, source, value) from pprint import pprint #pprint(situation)
from datetime import datetime from openfisca_core.simulations import Simulation import sys from pprint import pprint filename = '../doc/CMUCACS.csv' if len(sys.argv) > 1: filename = sys.argv[len(sys.argv) - 1] legislation_francaise = openfisca_france.FranceTaxBenefitSystem() with open(filename, 'r') as file: rows = csv.DictReader(file) for data in rows: period = datetime.strptime('2018-08-01', '%Y-%m-%d') situation = cpam_utils.createSituation(data, period) pprint(situation) simulation_actuelle = Simulation( tax_benefit_system=legislation_francaise, simulation_json=situation) variable = 'cmu_c' periodText = period.strftime('%Y-%m') resultat = simulation_actuelle.calculate(variable, periodText) print('{0} - {1} : {2}'.format(variable, periodText, resultat)) print('')
def build_from_entities(self, tax_benefit_system, input_dict): """ Build a simulation from a Python dict ``input_dict`` fully specifying entities. Examples: >>> simulation_builder.build_from_entities({ 'persons': {'Javier': { 'salary': {'2018-11': 2000}}}, 'households': {'household': {'parents': ['Javier']}} }) """ input_dict = deepcopy(input_dict) simulation = Simulation(tax_benefit_system, tax_benefit_system.instantiate_entities()) # Register variables so get_variable_entity can find them for (variable_name, _variable) in tax_benefit_system.variables.items(): self.register_variable(variable_name, simulation.get_variable_population(variable_name).entity) check_type(input_dict, dict, ['error']) axes = input_dict.pop('axes', None) unexpected_entities = [entity for entity in input_dict if entity not in tax_benefit_system.entities_plural()] if unexpected_entities: unexpected_entity = unexpected_entities[0] raise SituationParsingError([unexpected_entity], ''.join([ "Some entities in the situation are not defined in the loaded tax and benefit system.", "These entities are not found: {0}.", "The defined entities are: {1}."] ) .format( ', '.join(unexpected_entities), ', '.join(tax_benefit_system.entities_plural()) ) ) persons_json = input_dict.get(tax_benefit_system.person_entity.plural, None) if not persons_json: raise SituationParsingError([tax_benefit_system.person_entity.plural], 'No {0} found. At least one {0} must be defined to run a simulation.'.format(tax_benefit_system.person_entity.key)) persons_ids = self.add_person_entity(simulation.persons.entity, persons_json) for entity_class in tax_benefit_system.group_entities: instances_json = input_dict.get(entity_class.plural) if instances_json is not None: self.add_group_entity(self.persons_plural, persons_ids, entity_class, instances_json) else: self.add_default_group_entity(persons_ids, entity_class) if axes: self.axes = axes self.expand_axes() try: self.finalize_variables_init(simulation.persons) except PeriodMismatchError as e: self.raise_period_mismatch(simulation.persons.entity, persons_json, e) for entity_class in tax_benefit_system.group_entities: try: population = simulation.populations[entity_class.key] self.finalize_variables_init(population) except PeriodMismatchError as e: self.raise_period_mismatch(population.entity, instances_json, e) return simulation
def build(self, tax_benefit_system): return Simulation(tax_benefit_system, self.populations)
def get_simulation(json, **kwargs): return Simulation(tax_benefit_system=tax_benefit_system, simulation_json=json, **kwargs)
def build_from_entities(self, tax_benefit_system, input_dict): """ Build a simulation from a Python dict ``input_dict`` fully specifying entities. Examples: >>> simulation_builder.build_from_entities({ 'persons': {'Javier': { 'salary': {'2018-11': 2000}}}, 'households': {'household': {'parents': ['Javier']}} }) """ input_dict = deepcopy(input_dict) simulation = Simulation(tax_benefit_system, tax_benefit_system.instantiate_entities()) # Register variables so get_variable_entity can find them for (variable_name, _variable) in tax_benefit_system.variables.items(): self.register_variable(variable_name, simulation.get_variable_population(variable_name).entity) check_type(input_dict, dict, ['error']) axes = input_dict.pop('axes', None) unexpected_entities = [entity for entity in input_dict if entity not in tax_benefit_system.entities_plural()] if unexpected_entities: unexpected_entity = unexpected_entities[0] raise SituationParsingError([unexpected_entity], ''.join([ "Some entities in the situation are not defined in the loaded tax and benefit system.", "These entities are not found: {0}.", "The defined entities are: {1}."] ) .format( ', '.join(unexpected_entities), ', '.join(tax_benefit_system.entities_plural()) ) ) persons_json = input_dict.get(tax_benefit_system.person_entity.plural, None) if not persons_json: raise SituationParsingError([tax_benefit_system.person_entity.plural], 'No {0} found. At least one {0} must be defined to run a simulation.'.format(tax_benefit_system.person_entity.key)) persons_ids = self.add_person_entity(simulation.persons.entity, persons_json) for entity_class in tax_benefit_system.group_entities: instances_json = input_dict.get(entity_class.plural) if instances_json is not None: self.add_group_entity(self.persons_plural, persons_ids, entity_class, instances_json) else: self.add_default_group_entity(persons_ids, entity_class) if axes: self.axes = axes self.expand_axes() try: self.finalize_variables_init(simulation.persons) except PeriodMismatchError as e: self.raise_period_mismatch(simulation.persons.entity, persons_json, e) for entity_class in tax_benefit_system.group_entities: try: population = simulation.populations[entity_class.key] self.finalize_variables_init(population) except PeriodMismatchError as e: self.raise_period_mismatch(population.entity, instances_json, e) return simulation