def wrapper(f):
argspec = inspect.getargspec(f)
nkw = len(argspec.defaults) if argspec.defaults else 0
defaults = argspec.defaults if argspec.defaults else []
length_arguments = argspec.args[0:-nkw]
kwargs = argspec.args[-nkw:]
in_arg = OrderedDictionary()
for x, y in zip(kwargs, defaults):
in_arg[x] = y
out_arg = []
flatsrc = inspect.getsource(f).replace("\n", "").replace(" ", "")
def returns(**kwargs):
start = flatsrc.find("returns(")
order = lambda k: flatsrc.find(k[0] + "=", start)
out_arg.extend(sorted(kwargs.items(), key=order))
f.func_globals['returns'] = returns
f(*argspec.args)
out_arg_mapping = OrderedDictionary()
for x in out_arg:
out_arg_mapping[x[0]] = x[1]
function = get_function_specification(f.func_name, in_arg,
out_arg_mapping,
must_handle_array,
can_handle_array,
length_arguments)
def g():
return function
return g
def __init__(self, definitions, instance):
object.__setattr__(self, '_instance', weakref.ref(instance))
object.__setattr__(self, '_definitions', definitions)
object.__setattr__(self, '_mapping_from_name_to_definition', OrderedDictionary())
object.__setattr__(self, '_mapping_from_name_to_parameter', OrderedDictionary())
self.update()
def default_abundancies_table(self):
result = OrderedDictionary()
result['H'] = 1.
result['He'] = 0.1
result['Li'] = 0.
result['Be'] = 0.
result['B'] = 0.
result['C'] = 2.2e-4
result['N'] = 4.e-5
result['O'] = 3.3e-4
result['F'] = 0.
result['Ne'] = 5.e-5
result['Na'] = 0.
result['Mg'] = 0.
result['Al'] = 0.
result['Si'] = 0.
result['P'] = 0.
result['S'] = 9.e-6
result['Cl'] = 0.
result['Ar'] = 0.
result['K'] = 0.
result['Ca'] = 0.
result['Sc'] = 0.
result['Ti'] = 0.
result['V'] = 0.
result['Cr'] = 0.
result['Mn'] = 0.
result['Fe'] = 0.
result['Co'] = 0.
result['Ni'] = 0.
result['Cu'] = 0.
result['Zn'] = 0.
return result
def converted_results(self, dtype_to_result, must_handle_as_array):
number_of_outputs = len(self.specification.output_parameters)
result_type = self.specification.result_type
if number_of_outputs == 0:
if result_type is None:
return None
return dtype_to_result[result_type][0]
if number_of_outputs == 1 \
and result_type is None:
for value in dtype_to_result.values():
if len(value) == 1:
if must_handle_as_array:
return value
else:
return value[0]
result = OrderedDictionary()
dtype_to_array = {}
for key, value in dtype_to_result.iteritems():
dtype_to_array[key] = list(reversed(value))
if not result_type is None:
return_value = dtype_to_array[result_type].pop()
for parameter in self.specification.output_parameters:
result[parameter.name] = dtype_to_array[parameter.datatype].pop()
if not result_type is None:
result["__result"] = return_value
return result
def new_keyword_arguments_from_message(self, input_message, index, specification, units = []):
keyword_arguments = OrderedDictionary()
for parameter in specification.parameters:
attribute = self.dtype_to_message_attribute[parameter.datatype]
argument_value = None
if parameter.direction == LegacyFunctionSpecification.IN:
if specification.must_handle_array:
argument_value = getattr(input_message, attribute)[parameter.input_index]
else:
argument_value = getattr(input_message, attribute)[parameter.input_index][index]
if specification.has_units:
unit = units[parameter.index_in_input]
if not unit is None:
argument_value = argument_value | unit
elif parameter.direction == LegacyFunctionSpecification.INOUT:
if specification.must_handle_array:
argument_value = ValueHolder(getattr(input_message, attribute)[parameter.input_index])
else:
argument_value = ValueHolder(getattr(input_message, attribute)[parameter.input_index][index])
if specification.has_units:
unit = units[parameter.index_in_input]
if not unit is None:
argument_value.value = argument_value.value | unit
elif parameter.direction == LegacyFunctionSpecification.OUT:
argument_value = ValueHolder(None)
elif parameter.direction == LegacyFunctionSpecification.LENGTH:
argument_value = input_message.call_count
name = 'in_' if parameter.name == 'in' else parameter.name
keyword_arguments[name] = argument_value
return keyword_arguments
def send_cached_parameters_to_code(self):
cached_parameters = [x for x in self.iter_parameters() if x.definition.is_cached()]
for x in cached_parameters:
if not x.is_set:
x.set_default_value()
functions = OrderedDictionary()
for x in cached_parameters:
definition = x.definition
if not definition.functionname in functions:
functions[definition.functionname] = []
functions[definition.functionname].append(x)
for functionname, parameters in functions.iteritems():
object = self._instance()
method = getattr(object, functionname)
keyword_arguments = {}
for parameter in parameters:
keyword_arguments[parameter.definition.parameter_name] = parameter.get_cached_value()
errorcode = method(**keyword_arguments)
def send_cached_parameters_to_code(self):
cached_parameters = [x for x in self.iter_parameters() if x.definition.is_cached()]
for x in cached_parameters:
if not x.is_set:
x.set_default_value()
functions = OrderedDictionary()
for x in cached_parameters:
definition = x.definition
if not definition.functionname in functions:
functions[definition.functionname] = []
functions[definition.functionname].append(x)
for functionname, parameters in functions.items():
object = self._instance()
method = getattr(object, functionname)
keyword_arguments = {}
for parameter in parameters:
keyword_arguments[parameter.definition.parameter_name] = parameter.get_cached_value()
errorcode = method(**keyword_arguments)
