def test_irpp(year, irpp, **variables_value_by_name): simulation = simulations.Simulation(period=periods.period(year), tax_benefit_system=tax_benefit_system, debug=args.verbose) famille = simulation.entity_by_key_singular['famille'] foyer_fiscal = simulation.entity_by_key_singular['foyer_fiscal'] individu = simulation.entity_by_key_singular['individu'] menage = simulation.entity_by_key_singular['menage'] # Dispatch arguments to their respective entities. variables_value_by_name_by_entity = {} for variable_name, value in variables_value_by_name.iteritems(): variable_holder = simulation.get_or_new_holder(variable_name) entity_variables_value_by_name = variables_value_by_name_by_entity.setdefault( variable_holder.entity, {}) entity_variables_value_by_name[variable_name] = value add_member(famille, **variables_value_by_name_by_entity.get(famille, {})) add_member(foyer_fiscal, **variables_value_by_name_by_entity.get(foyer_fiscal, {})) add_member(menage, **variables_value_by_name_by_entity.get(menage, {})) add_member(individu, quifam=1, quifoy=1, quimen=1, **variables_value_by_name_by_entity.get(individu, {})) assert_near(simulation.calculate('irpp'), irpp, absolute_error_margin=0.51)
def new_simulation(self, debug=False, debug_all=False, reference=False, trace=False, survey=None): assert self.tax_benefit_system is not None tax_benefit_system = self.tax_benefit_system if self.reference_tax_benefit_system is not None and reference: tax_benefit_system = self.reference_tax_benefit_system elif reference: while True: reference_tax_benefit_system = tax_benefit_system.reference if isinstance(reference, bool) and reference_tax_benefit_system is None \ or reference_tax_benefit_system == reference: break tax_benefit_system = reference_tax_benefit_system period = periods.period(self.year) self.neutralize_variables(tax_benefit_system) simulation = simulations.Simulation( debug=debug, debug_all=debug_all, opt_out_cache=True if self.cache_blacklist is not None else False, period=period, tax_benefit_system=tax_benefit_system, trace=trace, ) # Case 1: fill simulation with a unique input_data_frame given by the attribute if self.input_data_frame is not None: input_data_frame = self.input_data_frame.copy() self.custom_input_data_frame(input_data_frame, period=period) self.fill(input_data_frame, simulation, period) # Case 2: fill simulation with input_data_frame by period containing all entity variables elif self.input_data_table_by_period is not None: for period, table in self.input_data_table_by_period.iteritems(): period = periods.period(period) input_data_frame = self.load_table(survey=survey, table=table) self.custom_input_data_frame(input_data_frame, period=period) self.fill(input_data_frame, simulation, period) # if not reference: self.simulation = simulation else: self.reference_simulation = simulation # if 'custom_initialize' in dir(self): self.custom_initialize(simulation) # return simulation
def check_revenu_disponible(year, city_code, expected_revenu_disponible): simulation = simulations.Simulation(period=periods.period(year), tax_benefit_system=tax_benefit_system) famille = simulation.populations["famille"] famille.count = 3 famille.roles_count = 2 famille.step_size = 1 individu = simulation.populations["individu"] individu.count = 6 individu.step_size = 2 simulation.get_or_new_holder("city_code").array = np.array( [city_code, city_code, city_code]) famille.members_entity_id = np.array([0, 0, 1, 1, 2, 2]) simulation.get_or_new_holder("salaire_brut").array = np.array( [0.0, 0.0, 50000.0, 0.0, 100000.0, 0.0]) revenu_disponible = simulation.calculate('revenu_disponible') assert_near(revenu_disponible, expected_revenu_disponible, absolute_error_margin=0.005)
def create_simulation(data, period, tax_benefit_system): result = simulations.Simulation( debug=False, period=period, tax_benefit_system=tax_benefit_system, ) # Initialize entities, assuming there is only one person and one of each other entities ("familles", # "foyers fiscaux", etc). for entity in result.entity_by_key_plural.itervalues(): entity.count = 1 entity.roles_count = 1 entity.step_size = 1 # Link person to its entities using ID & role. for entity in result.entity_by_key_plural.itervalues(): if not entity.is_persons_entity: holder = result.get_or_new_holder( entity.index_for_person_variable_name) holder.put_in_cache(np.array([0]), period) holder = result.get_or_new_holder( entity.role_for_person_variable_name) holder.put_in_cache(np.array([0]), period) # Inject all variables from query string into arrays. for column_name, value in data.iteritems(): column = tax_benefit_system.column_by_name[column_name] holder = result.get_or_new_holder(column_name) if period.unit == 'year': holder.put_in_cache(np.array([value], dtype=column.dtype), period) elif period.unit == 'month': # Inject inputs for all months of year year = period.start.year month_index = 1 while month_index <= 12: month = periods.period('{}-{:02d}'.format(year, month_index)) holder.put_in_cache(np.array([value], dtype=column.dtype), month) month_index += 1 return result
def check_revenu_disponible(year, depcom, expected_revenu_disponible): simulation = simulations.Simulation(period=periods.period(year), tax_benefit_system=tax_benefit_system) famille = simulation.entity_by_key_singular["famille"] famille.count = 3 famille.roles_count = 2 famille.step_size = 1 individu = simulation.entity_by_key_singular["individu"] individu.count = 6 individu.step_size = 2 simulation.get_or_new_holder("depcom").array = np.array( [depcom, depcom, depcom]) simulation.get_or_new_holder("id_famille").array = np.array( [0, 0, 1, 1, 2, 2]) simulation.get_or_new_holder("role_dans_famille").array = np.array( [PARENT1, PARENT2, PARENT1, PARENT2, PARENT1, PARENT2]) simulation.get_or_new_holder("salaire_brut").array = np.array( [0.0, 0.0, 50000.0, 0.0, 100000.0, 0.0]) revenu_disponible = simulation.calculate('revenu_disponible') assert_near(revenu_disponible, expected_revenu_disponible, absolute_error_margin=0.005)
def new_simulation(self, debug=False, use_baseline=False, trace=False, opt_out_cache=False): assert isinstance(use_baseline, (bool, int)), \ 'Parameter use_baseline must be a boolean. When True, the baseline tax-benefit system is used.' 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 simulation = simulations.Simulation( debug=debug, period=self.period, tax_benefit_system=tax_benefit_system, trace=trace, opt_out_cache=opt_out_cache, ) self.fill_simulation(simulation) return simulation
def api1_field(req): ctx = contexts.Ctx(req) headers = wsgihelpers.handle_cross_origin_resource_sharing(ctx) assert req.method == 'GET', req.method params = req.GET inputs = dict( context = params.get('context'), input_variables = params.get('input_variables'), reforms = params.getall('reform'), variable = params.get('variable'), ) str_list_to_reforms = conv.make_str_list_to_reforms() data, errors = conv.pipe( conv.struct( dict( context = conv.noop, # For asynchronous calls input_variables = conv.pipe( conv.test_isinstance((bool, int, basestring)), conv.anything_to_bool, conv.default(True), ), reforms = str_list_to_reforms, variable = conv.noop, # Real conversion is done once tax-benefit system is known. ), default = 'drop', ), )(inputs, state = ctx) if errors is None: country_tax_benefit_system = model.tax_benefit_system tax_benefit_system = model.get_cached_composed_reform( reform_keys = data['reforms'], tax_benefit_system = country_tax_benefit_system, ) if data['reforms'] is not None else country_tax_benefit_system data, errors = conv.struct( dict( variable = conv.pipe( conv.empty_to_none, conv.default(u'revdisp'), conv.test_in(tax_benefit_system.column_by_name), ), ), default = conv.noop, )(data, state = ctx) if errors is not None: return wsgihelpers.respond_json(ctx, collections.OrderedDict(sorted(dict( apiVersion = 1, context = inputs.get('context'), error = collections.OrderedDict(sorted(dict( code = 400, # Bad Request errors = [conv.jsonify_value(errors)], message = ctx._(u'Bad parameters in request'), ).iteritems())), method = req.script_name, params = inputs, url = req.url.decode('utf-8'), ).iteritems())), headers = headers, ) variable_name = data['variable'] column = tax_benefit_system.column_by_name[variable_name] value_json = column.to_json() if data['input_variables'] and not column.is_input_variable(): simulation = simulations.Simulation( period = periods.period(datetime.date.today().year), tax_benefit_system = tax_benefit_system, ) holder = simulation.get_or_new_holder(variable_name) value_json['formula'] = holder.formula.to_json( get_input_variables_and_parameters = model.get_cached_input_variables_and_parameters, with_input_variables_details = True, ) value_json['entity'] = column.entity # Overwrite with symbol instead of key plural for compatibility. return wsgihelpers.respond_json(ctx, collections.OrderedDict(sorted(dict( apiStatus = u'deprecated', apiVersion = 1, context = data['context'], method = req.script_name, params = inputs, url = req.url.decode('utf-8'), value = value_json, ).iteritems())), headers = headers, )
def api1_variables(req): ctx = contexts.Ctx(req) headers = wsgihelpers.handle_cross_origin_resource_sharing(ctx) assert req.method == 'GET', req.method params = req.GET inputs = dict(names=params.getall('name'), ) tax_benefit_system = model.tax_benefit_system tax_benefit_system_variables_name = tax_benefit_system.column_by_name.keys( ) data, errors = conv.pipe( conv.struct( dict(names=conv.pipe( conv.uniform_sequence( conv.pipe( conv.empty_to_none, conv.test_in(tax_benefit_system_variables_name, error=u'Variable does not exist'), ), drop_none_items=True, ), conv.empty_to_none, ), ), default='drop', ), )(inputs, state=ctx) if errors is not None: return wsgihelpers.respond_json( ctx, collections.OrderedDict( sorted( dict( apiVersion=1, error=collections.OrderedDict( sorted( dict( code=400, # Bad Request errors=[conv.jsonify_value(errors)], message=ctx._( u'Bad parameters in request'), ).iteritems())), method=req.script_name, params=inputs, url=req.url.decode('utf-8'), ).iteritems())), headers=headers, ) simulation = None variables_json = [] for variable_name in data['names'] or tax_benefit_system_variables_name: column = tax_benefit_system.column_by_name[variable_name] variable_json = column.to_json() variable_json['source_file_path'] = environment.get_relative_file_path( variable_json['source_file_path']) label = variable_json.get('label') if label is not None and label == variable_name: del variable_json['label'] if not column.is_input_variable(): if simulation is None: simulation = simulations.Simulation( period=periods.period(datetime.date.today().year), tax_benefit_system=model.tax_benefit_system, ) holder = simulation.get_or_new_holder(variable_name) variable_json['formula'] = holder.formula.to_json( get_input_variables_and_parameters=model. get_cached_input_variables_and_parameters, ) variables_json.append(variable_json) response_dict = dict( apiVersion=1, country_package_name=conf['country_package'], country_package_version=environment.country_package_version, method=req.script_name, url=req.url.decode('utf-8'), variables=variables_json, ) if hasattr(tax_benefit_system, 'CURRENCY'): response_dict['currency'] = tax_benefit_system.CURRENCY return wsgihelpers.respond_json( ctx, collections.OrderedDict(sorted(response_dict.iteritems())), headers=headers, )
def new_simulation(self, debug=False, debug_all=False, trace=False): input_data_frame = self.input_data_frame # TODO: Pass year to this method, not init_from_data_frame simulation = simulations.Simulation( debug=debug, debug_all=debug_all, period=periods.period(self.year), tax_benefit_system=self.tax_benefit_system, trace=trace, ) symbols_other_than_ind = [ entity.symbol for entity in simulation.entity_by_key_singular.values() ] symbols_other_than_ind.remove('ind') id_variables = [ "id{}".format(symbol) for symbol in symbols_other_than_ind ] role_variables = [ "qui{}".format(symbol) for symbol in symbols_other_than_ind ] for id_variable in id_variables + role_variables: assert id_variable in self.input_data_frame.columns column_by_name = self.tax_benefit_system.column_by_name for column_name in input_data_frame: if column_name not in column_by_name: log.info( 'Unknown column "{}" in survey, dropped from input table'. format(column_name)) # waiting for the new pandas version to hit Travis repo input_data_frame = input_data_frame.drop(column_name, axis=1) # , inplace = True) # TODO: effet de bords ? for column_name in input_data_frame: if column_by_name[column_name].formula_class is not None: log.info( 'Column "{}" in survey set to be calculated, dropped from input table' .format(column_name)) input_data_frame = input_data_frame.drop(column_name, axis=1) # , inplace = True) # TODO: effet de bords ? for entity in simulation.entity_by_key_singular.values(): if entity.is_persons_entity: entity.count = entity.step_size = len(input_data_frame) else: entity.count = entity.step_size = ( input_data_frame["qui{}".format( entity.symbol)] == 0).sum() entity.roles_count = input_data_frame["qui{}".format( entity.symbol)].max() + 1 # TODO: Create a validation/conversion step # TODO: introduce an assert when loading in place of astype for column_name, column_series in input_data_frame.iteritems(): holder = simulation.get_or_new_holder(column_name) entity = holder.entity if entity.is_persons_entity: array = column_series.values.astype(holder.column.dtype) else: array = column_series.values[input_data_frame[ 'qui' + entity.symbol].values == 0].astype( holder.column.dtype) assert array.size == entity.count, 'Bad size for {}: {} instead of {}'.format( column_name, array.size, entity.count) holder.array = np.array(array, dtype=holder.column.dtype) self.simulation = simulation return simulation
def new_simulation_from_array_dict(array_dict=None, debug=False, debug_all=False, legislation_json=None, tax_benefit_system=None, trace=False, year=None): simulation = simulations.Simulation( debug=debug, debug_all=debug_all, legislation_json=legislation_json, period=periods.period(year), tax_benefit_system=tax_benefit_system, trace=trace, ) assert len(set(len(x) for x in array_dict.itervalues() if len(x) != 1)) == 1, 'Arrays do not have the same size' global_count = len(array_dict.values()[0]) for role_var in ['quifam', 'quifoy', 'quimen']: if role_var not in array_dict: array_dict[role_var] = np.zeros(global_count, dtype=int) for id_var in ['idfam', 'idfoy', 'idmen']: if id_var not in array_dict: array_dict[id_var] = np.arange(global_count, dtype=int) column_by_name = tax_benefit_system.column_by_name for column_name, array in array_dict.iteritems(): assert column_name in column_by_name, column_name entity_by_key_plural = simulation.entity_by_key_plural familles = entity_by_key_plural[u'familles'] familles.count = familles.step_size = (array_dict['quifam'] == 0).sum() foyers_fiscaux = entity_by_key_plural[u'foyers_fiscaux'] foyers_fiscaux.count = foyers_fiscaux.step_size = ( array_dict['quifoy'] == 0).sum() individus = entity_by_key_plural[u'individus'] individus.count = individus.step_size = global_count menages = entity_by_key_plural[u'menages'] menages.count = menages.step_size = (array_dict['quimen'] == 0).sum() assert 'idfam' in array_dict.keys() assert 'idfoy' in array_dict.keys() assert 'idmen' in array_dict.keys() assert 'quifam' in array_dict.keys() assert 'quifoy' in array_dict.keys() assert 'quimen' in array_dict.keys() familles.roles_count = array_dict['quifam'].max() + 1 menages.roles_count = array_dict['quimen'].max() + 1 foyers_fiscaux.roles_count = array_dict['quifoy'].max() + 1 for column_name, column_array in array_dict.iteritems(): holder = simulation.get_or_new_holder(column_name) entity = holder.entity if entity.is_persons_entity: array = column_array else: array = column_array[array_dict['qui' + entity.symbol].values == 0] assert array.size == entity.count, 'Bad size for {}: {} instead of {}'.format( column_name, array.size, entity.count) holder.array = np.array(array, dtype=holder.column.dtype) return simulation
def api1_variables(req): wsgihelpers.track(req.url.decode('utf-8')) ctx = contexts.Ctx(req) headers = wsgihelpers.handle_cross_origin_resource_sharing(ctx) assert req.method == 'GET', req.method params = req.GET inputs = dict( names = params.getall('name'), ) tax_benefit_system = model.tax_benefit_system tax_benefit_system_variables_name = tax_benefit_system.variables.keys() data, errors = conv.pipe( conv.struct( dict( names = conv.pipe( conv.uniform_sequence( conv.pipe( conv.empty_to_none, conv.test_in(tax_benefit_system_variables_name, error = u'Variable does not exist'), ), drop_none_items = True, ), conv.empty_to_none, ), ), default = 'drop', ), )(inputs, state = ctx) if errors is not None: return wsgihelpers.respond_json(ctx, collections.OrderedDict(sorted(dict( apiVersion = 1, error = collections.OrderedDict(sorted(dict( code = 400, # Bad Request errors = [conv.jsonify_value(errors)], message = ctx._(u'Bad parameters in request'), ).iteritems())), method = req.script_name, params = inputs, url = req.url.decode('utf-8'), ).iteritems())), headers = headers, ) simulation = None variables_json = [] for variable_name in data['names'] or tax_benefit_system_variables_name: variable = tax_benefit_system.variables[variable_name] column = columns.make_column_from_variable(variable) variable_json = column.to_json() # This part checks that no enum tries to go through the API if 'cerfa_field' in variable_json.keys(): cerfa = variable_json['cerfa_field'] for key in cerfa: from enum import Enum if isinstance(key, Enum): cerfa[key.name] = cerfa[key] del cerfa[key] if variable_json.get('source_file_path'): variable_json['source_file_path'] = environment.get_relative_file_path(variable_json['source_file_path']) label = variable_json.get('label') if label is not None and label == variable_name: del variable_json['label'] if not column.is_input_variable(): if simulation is None: simulation = simulations.Simulation( period = periods.period(datetime.date.today().year), tax_benefit_system = model.tax_benefit_system, ) variables_json.append(variable_json) response_dict = dict( apiVersion = 1, country_package_name = conf['country_package'], country_package_version= environment.country_package_version, method = req.script_name, url = req.url.decode('utf-8'), variables = variables_json, ) if hasattr(tax_benefit_system, 'CURRENCY'): response_dict['currency'] = tax_benefit_system.CURRENCY return wsgihelpers.respond_json(ctx, collections.OrderedDict(sorted(response_dict.iteritems())), headers = headers, )
def new_simulation(self, debug = False, debug_all = False, reference = False, trace = False): assert self.tax_benefit_system is not None tax_benefit_system = self.tax_benefit_system if self.reference_tax_benefit_system is not None and reference: tax_benefit_system = self.reference_tax_benefit_system elif reference: while True: reference_tax_benefit_system = tax_benefit_system.reference if isinstance(reference, bool) and reference_tax_benefit_system is None \ or reference_tax_benefit_system == reference: break tax_benefit_system = reference_tax_benefit_system simulation = simulations.Simulation( debug = debug, debug_all = debug_all, period = periods.period(self.year), tax_benefit_system = tax_benefit_system, trace = trace, ) id_variables = [ entity.index_for_person_variable_name for entity in simulation.entity_by_key_singular.values() if not entity.is_persons_entity] role_variables = [ entity.role_for_person_variable_name for entity in simulation.entity_by_key_singular.values() if not entity.is_persons_entity] column_by_name = tax_benefit_system.column_by_name used_as_input_variables = self.used_as_input_variables # Define a useful function to clean the data_frame def filter_input_variables(input_data_frame): for column_name in input_data_frame: if column_name not in column_by_name: log.info('Unknown column "{}" in survey, dropped from input table'.format(column_name)) input_data_frame.drop(column_name, axis = 1, inplace = True) for column_name in input_data_frame: if column_name in id_variables + role_variables: continue column = column_by_name[column_name] function = getattr(column.formula_class, 'function', None) if function is not None: if column_name in used_as_input_variables: log.info( 'Column "{}" not dropped because present in used_as_input_variables'.format(column_name)) continue log.info('Column "{}" in survey set to be calculated, dropped from input table'.format(column_name)) input_data_frame.drop(column_name, axis = 1, inplace = True) # # # return input_data_frame assert self.input_data_frame is not None or self.input_data_frames_by_entity_key_plural is not None input_data_frame = self.input_data_frame input_data_frames_by_entity_key_plural = self.input_data_frames_by_entity_key_plural # Case 1: fill simulation with a unique input_data_frame containing all entity variables if input_data_frame is not None: for id_variable in id_variables + role_variables: assert id_variable in input_data_frame.columns, \ "Variable {} is not present in input dataframe".format(id_variable) input_data_frame = filter_input_variables(input_data_frame) for entity in simulation.entity_by_key_singular.values(): if entity.is_persons_entity: entity.count = entity.step_size = len(input_data_frame) else: entity.count = entity.step_size = \ (input_data_frame[entity.role_for_person_variable_name] == 0).sum() entity.roles_count = input_data_frame[entity.role_for_person_variable_name].max() + 1 unique_ids_count = len(input_data_frame[entity.index_for_person_variable_name].unique()) assert entity.count == unique_ids_count, \ "There are {0} person of role 0 in {1} but {2} {1}".format( entity.count, entity.key_plural, unique_ids_count) for column_name, column_serie in input_data_frame.iteritems(): holder = simulation.get_or_new_holder(column_name) entity = holder.entity if column_serie.values.dtype != holder.column.dtype: log.info( 'Converting {} from dtype {} to {}'.format( column_name, column_serie.values.dtype, holder.column.dtype) ) if np.issubdtype(column_serie.values.dtype, np.float): if column_serie.isnull().any(): log.info('There are {} NaN values for {} non NaN values in variable {}'.format( column_serie.isnull().sum(), column_serie.notnull().sum(), column_name)) log.info('We convert these NaN values of variable {} to {} its default value'.format( column_name, holder.column.default)) input_data_frame.loc[column_serie.isnull(), column_name] = holder.column.default assert input_data_frame[column_name].notnull().all(), \ 'There are {} NaN values fo {} non NaN values in variable {}'.format( column_serie.isnull().sum(), column_serie.notnull().sum(), column_name) if entity.is_persons_entity: array = column_serie.values.astype(holder.column.dtype) else: array = column_serie.values[ input_data_frame[entity.role_for_person_variable_name].values == 0 ].astype(holder.column.dtype) assert array.size == entity.count, 'Bad size for {}: {} instead of {}'.format( column_name, array.size, entity.count) holder.array = np.array(array, dtype = holder.column.dtype) # Case 2: fill simulation with an input_data_frame by entity elif input_data_frames_by_entity_key_plural is not None: for entity in simulation.entity_by_key_singular.values(): if entity.index_for_person_variable_name is not None: input_data_frame = input_data_frames_by_entity_key_plural[entity.index_for_person_variable_name] else: input_data_frame = input_data_frames_by_entity_key_plural['individus'] input_data_frame = filter_input_variables(input_data_frame) if entity.is_persons_entity: entity.count = entity.step_size = len(input_data_frame) else: entity.count = entity.step_size = len(input_data_frame) entity.roles_count = input_data_frames_by_entity_key_plural['individus'][ entity.role_for_person_variable_name].max() + 1 # Convert columns from df to array: for column_name, column_serie in input_data_frame.iteritems(): holder = simulation.get_or_new_holder(column_name) entity = holder.entity if column_serie.values.dtype != holder.column.dtype: log.info( 'Converting {} from dtype {} to {}'.format( column_name, column_serie.values.dtype, holder.column.dtype) ) if np.issubdtype(column_serie.values.dtype, np.float): assert column_serie.notnull().all(), 'There are {} NaN values in variable {}'.format( column_serie.isnull().sum(), column_name) array = column_serie.values.astype(holder.column.dtype) assert array.size == entity.count, 'Bad size for {}: {} instead of {}'.format( column_name, array.size, entity.count) holder.array = np.array(array, dtype = holder.column.dtype) if not reference: self.simulation = simulation else: self.reference_simulation = simulation if 'custom_initialize' in dir(self): self.custom_initialize() return simulation
def api1_graph(req): ctx = contexts.Ctx(req) headers = wsgihelpers.handle_cross_origin_resource_sharing(ctx) assert req.method == 'GET', req.method params = req.GET inputs = dict( context=params.get('context'), reforms=params.getall('reform'), variable=params.get('variable'), ) if model.input_variables_extractor is None: return wsgihelpers.respond_json( ctx, collections.OrderedDict( sorted( dict( apiVersion=1, context=inputs.get('context'), error=collections.OrderedDict( sorted( dict( code=501, errors=[ ctx. _(u'openfisca_parsers is not installed on this instance of the API' ) ], message=ctx._(u'Not implemented'), ).iteritems())), method=req.script_name, params=inputs, url=req.url.decode('utf-8'), ).iteritems())), headers=headers, ) str_list_to_reforms = conv.make_str_list_to_reforms() data, errors = conv.pipe( conv.struct( dict( context=conv.noop, # For asynchronous calls reforms=str_list_to_reforms, variable=conv. noop, # Real conversion is done once tax-benefit system is known. ), default='drop', ), )(inputs, state=ctx) if errors is None: country_tax_benefit_system = model.tax_benefit_system tax_benefit_system = model.get_cached_composed_reform( reform_keys=data['reforms'], tax_benefit_system=country_tax_benefit_system, ) if data['reforms'] is not None else country_tax_benefit_system data, errors = conv.struct( dict(variable=conv.pipe( conv.empty_to_none, conv.default(u'revenu_disponible'), conv.test_in(tax_benefit_system.column_by_name), ), ), default=conv.noop, )(data, state=ctx) if errors is not None: return wsgihelpers.respond_json( ctx, collections.OrderedDict( sorted( dict( apiVersion=1, context=inputs.get('context'), error=collections.OrderedDict( sorted( dict( code=400, # Bad Request errors=[conv.jsonify_value(errors)], message=ctx._( u'Bad parameters in request'), ).iteritems())), method=req.script_name, params=inputs, url=req.url.decode('utf-8'), ).iteritems())), headers=headers, ) simulation = simulations.Simulation( period=periods.period(datetime.date.today().year), tax_benefit_system=tax_benefit_system, ) edges = [] nodes = [] visited = set() simulation.graph( column_name=data['variable'], edges=edges, get_input_variables_and_parameters=model. get_cached_input_variables_and_parameters, nodes=nodes, visited=visited, ) return wsgihelpers.respond_json( ctx, collections.OrderedDict( sorted( dict( apiVersion=1, context=data['context'], edges=edges, method=req.script_name, nodes=nodes, params=inputs, url=req.url.decode('utf-8'), ).iteritems())), headers=headers, )