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)