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