def valid_arguments(function, arguments): """ Returns boolean indicating if all arguments are supplied. :param function: object. :param arguments: dict with arguments. :return: Boolean. """ # TODO: deal with optional arguments. for var in helpers.get_function_inputs(function): if var not in arguments: return False return True
def get_function_code(self, signature, expression_expected, table, fun): """ Tests that a right function definition is generated. :param signature: of the function eg: sum(a,b). :param table: truth table. """ expected_code = ["def " + signature + ":", " return " + expression_expected] inputs = get_function_inputs(fun) expression = s.get_function_expression(table, inputs) definition = 'def ' + signature code = s.add_code_to_implementation(current_implementation=s.get_initial_implementation(definition), bool_expression=expression, definition=definition, the_output=True) self.assertListEqual(code, expected_code)
def return_solution(unittest, f, conditions): """ Solves the riddle, Writes it and tests it. :param unittest: the unittest object that is passed to test stuff :param f: any function object. :param conditions: condition or object or partial truth table (explicit, implicit or mix). :return: True for successful operation, False if not. """ f_path = h.get_function_path(f) file_code = h.read_file(f_path) f_line = h.get_function_line_number(f, file_code) # enters only if the function source code was found. if f_line > 0 and get_signature(file_code[f_line]): definition = file_code[f_line] function_inputs = h.get_function_inputs(f) # init variables implementation = get_initial_implementation(definition) processed_conditions = get_processed_conditions(conditions, function_inputs) for the_output, table in processed_conditions.tables.iteritems(): all_inputs = get_input_values(conditions, function_inputs, the_output) expression = get_function_expression(table, all_inputs) if len(expression) > 0: implementation = add_code_to_implementation(current_implementation=implementation, bool_expression=expression, definition=definition, the_output=the_output) implementation = add_default_return(definition, processed_conditions, implementation) solution = Solution(implementation=implementation, function=f, conditions=conditions, processed_conditions=processed_conditions) test_implementation(unittest, solution) alter_file(f_line, file_code, implementation, f_path) print "Solved and tested " + f.__name__ return solution return get_empty_solution(f, conditions)
def print_invoked_function(output): """ Prints a function that is invoked with arguments: eg: fun(a, b) :param output: a c.Output object :return: string """ if isinstance(output, c.Output): args_dict = output.arguments args_str = '' for var in helpers.get_function_inputs(output.function): if args_str == '': args_str += print_object(args_dict[var]) else: args_str += ', ' + print_object(args_dict[var]) return output.function.__name__ + '(' + args_str + ')' else: warnings.warn('method is not receiving correct data type', UserWarning)