def preliminary(self, view_information, query_description, extra={}): selection = self._get_selection(view_information, extra) build = self.general_build if not build or not build[0]: return None, None, None, None root, atok, m, r = build selection = m.forward(selection) origin = nearest_node_from_offset( root, atok, selection[0]) if selection[0] == selection[1] else node_from_range( root, atok, selection) definition_node = search_upwards( origin, ast.FunctionDef) # ,aybe need to change that in the future # in order to find the outermost function. if definition_node and definition_node.first_token.startpos > selection[ 1]: token = atok.get_token_from_offset(selection[0]) while token.string.isspace(): token = atok.prev_token(token) s = token.startpos origin = nearest_node_from_offset(root, atok, s) definition_node = search_upwards(origin, ast.FunctionDef) definition_node = ( definition_node if definition_node and query_description["big_roi"] not in [ "import statement", "import module", "import value", "class name", "base class", "decorator" ] else root) return build, selection, origin, definition_node
def get_statement(self, origin, atok): # print("\norigin\n",ast.dump(origin)) self.global_constrained_space = None candidate_statement = search_upwards(origin, ast.stmt) big = (ast.If, ast.While, ast.For, ast.FunctionDef, ast.With, ast.ClassDef, ast.Try, ast.ExceptHandler) if match_node(candidate_statement, big): candidate_statement = search_upwards_for_parent(origin, ast.stmt) candidate_statement = candidate_statement if candidate_statement else search_upwards( origin, ast.stmt) if match_node(candidate_statement, big): region = get_source_region( atok, get_weak_header(candidate_statement, atok)) if region: self.global_constrained_space = region return candidate_statement
def handle_single(self,view_information,query_description,extra = {}): build, selection, origin = self._preliminary(view_information = view_information,query_description = query_description,extra = extra) if not build: return None,None root,atok,m,r = build definition_nodes = [search_upwards(origin,ast.FunctionDef)] if query_description["format"]>=2 else find_all_nodes(root,ast.FunctionDef) if query_description["format"]>=2: if "vertical_direction" in query_description: definition_node = definition_nodes[0] temporary_information = lambda x: match_node(x,ast.FunctionDef) direction = query_description["vertical_direction"] ndir = query_description["ndir"] row = view_information["rowcol"](m.backward(selection)[0])[0] + 1 if definition_node is None else definition_node.first_token.start[0] bonus = 1 if definition_node.first_token.startpos > selection[1] else 0 t = decode_abstract_vertical(root,atok,(),row, ndir + bonus,direction,True,temporary_information) definition_nodes = [t] name_nodes = make_flat([get_argument_from_definition(x) for x in definition_nodes]) names = list(OrderedDict([(x,0) for x in name_nodes]).keys()) if "experimental" in query_description: names = [x + "=" + x for x in names] if query_description["format"]==1: result = None else: mode = { 2:"individual", 3:"range", }[query_description["format"]] result = ",".join(decode_item_selection(names,query_description,mode,"item_index")) return result, names
def case_two(self,view_information,query_description, extra = {}): ################################################################ # <vertical_direction> <ndir> <adjective> argument <argument_index> ############################################################### selection = self._get_selection(view_information,extra) vertical_direction = query_description["vertical_direction"] ndir = query_description["ndir"] if vertical_direction in ["up","down"]: row, column = view_information["rowcol"](m.backward(selection)[0]) nr = max(0,row + ndir if vertical_direction=="down" else row - ndir) t = view_information["text_point"](nr,0) selection = (t,t) build = self.general_build if self.general_build else line_partial(selection[0]) if not build or not build[0] : return None,None root,atok,m,r = build selection = m.forward(selection) # this is the wrong but for some reason it is working:) if vertical_direction in ["above","below"]: row, column = view_information["rowcol"](m.backward(selection)[0]) nr = decode_abstract_vertical(root,atok,ast.Call,row+1, ndir,vertical_direction)-1 t = view_information["text_point"](nr,0) selection = (t,t) selection = m.forward(selection) origin = nearest_node_from_offset(root,atok, selection[0]) if selection[0]==selection[1] else node_from_range(root,atok, selection) statement_node = search_upwards(origin,ast.stmt) # alternative_logical_lines = find_all_nodes(statement_node.parent,selector = lambda x:match_node(x,ast.stmt) and x.first_token.start[0]==origin.first_token.start[0] ,visit_all_levels=False) sharing_physical = alternative_logical_lines not in [[] ,[statement_node]] priority = {"root_lexical_order":1} if ( statement_node.first_token.start[0] != origin.first_token.start[0] or sharing_physical) else {} result, alternatives = self.process_line( q = query_description, root = statement_node if not sharing_physical else statement_node.parent, atok = atok, origin = None, select_node = None, tiebreaker = lambda x: tiebreak_on_lca(statement_node if not sharing_physical else statement_node.parent,origin,x), line = nr+1, priority = priority, constrained_space = m.forward((view_information["text_point"](nr ,0),view_information["text_point"](nr + 1,0))), second_tiebreaker = lambda x,y : tiebreak_on_visual(row + 1,x,y) ) if sharing_physical: if alternatives: alternatives = [x for x in alternatives if x.first_token.start[0]==origin.first_token.start[0]] if result and result.first_token.start[0]!=origin.first_token.start[0]: result, alternatives = obtain_result(result, alternatives) return self._backward_result(result, alternatives,build)
def case_three(self, view_information, query_description, extra={}): ################################################################ # <vertical_abstract_only_direction> [<ndir>] <big_roi> [<big_roi_sub_index>] ############################################################### build, selection, origin, definition_node = self.preliminary( view_information, query_description, extra) targets, exclusions, information = self.decode(query_description, build) root, atok, m, r = build temporary_information = lambda x: information(x) if match_node( x, targets, exclusions) and generic_fix(x, atok) else None direction = query_description["vertical_direction"] ndir = query_description["ndir"] row, column = view_information["rowcol"](m.backward(selection)[0]) # bug fixing test_result = decode_abstract_vertical(root, atok, targets, row + 1, 1, direction, True, temporary_information, want_alternatives=False) l = search_upwards_log(origin, ast.stmt) if (test_result in [l[0]] + l[1] and row + 1 >= test_result.first_token.start[0] and row + 1 <= test_result.last_token.end[0]): ndir = ndir + 1 result, alternatives = decode_abstract_vertical(root, atok, targets, row + 1, ndir, direction, True, temporary_information, want_alternatives=True) if result: new_definition_node = search_upwards(result, ast.FunctionDef) if definition_node is not new_definition_node and new_definition_node is not None: alternatives = tiebreak_on_lca( new_definition_node, result, find_all_nodes(new_definition_node, targets, exclusions)) result, alternatives = obtain_result(result, alternatives) information = getattr(information, "secondary", information) result = information(result) if result else None alternatives = [information(x) for x in alternatives] if alternatives else [] return self._backward_result(result, alternatives, build)
def case_three(self,view_information,query_description, extra = {}): ################################################################ # <adjective> inside <level_index> argument <argument_index> ############################################################### selection = self._get_selection(view_information,extra) build = self.general_build if self.general_build else line_partial(selection[0]) if not build or not build[0] : return None,None root,atok,m,r = build selection = m.forward(selection) origin = nearest_node_from_offset(root,atok, selection[0]) if selection[0]==selection[1] else node_from_range(root,atok, selection) statement_node = search_upwards(origin,ast.stmt) ############################################################### # transformations ################################################################ temporary = {} lca = LCA(statement_node) def transformation(node): calling_parent = search_upwards_for_parent(node,ast.Call) calling_parent = calling_parent.parent if calling_parent else None if not calling_parent: return None field,field_index = lca.get_field_with_respect_to(node,calling_parent) if correspond_to_index_in_call(calling_parent,query_description["level_index"]-1,field,field_index): if calling_parent not in temporary: temporary[calling_parent] = [] temporary[calling_parent].append(node) return calling_parent else: return None def inverse_transformation(node): if node in temporary: return temporary[node] else: return None result, alternatives = self.process_line( q = query_description, root = statement_node, atok = atok, origin = origin, select_node = origin if selection[0]!=selection[1] else None, tiebreaker = lambda x: tiebreak_on_lca(statement_node,origin,x), transformation = transformation, inverse_transformation = inverse_transformation ) return self._backward_result(result, alternatives,build)
def handle_single(self, view_information, query_description, extra={}): build, selection, origin = self._preliminary(view_information, query_description, extra) if not build: return None, None root, atok, m, r = build definition_node = search_upwards( origin, ast.ClassDef) if query_description["format"] != 1 else root temporary = find_matching(definition_node, is_decorator) name_nodes = [ get_decorator_text(x, atok, False) for x in temporary ] + [get_decorator_text(x, atok, True) for x in temporary] name_nodes = [(x, 0) for x in name_nodes if x] names = list(OrderedDict(name_nodes).keys()) return names
def case_four(self,view_information,query_description, extra = {}): ################################################################ # <adjective> inside <level_index> argument <argument_index> ############################################################### selection = self._get_selection(view_information,extra) build = self.general_build if self.general_build else line_partial(selection[0]) if not build or not build[0] : return None,None root,atok,m,r = build selection = m.forward(selection) origin = nearest_node_from_offset(root,atok, selection[0]) if selection[0]==selection[1] else node_from_range(root,atok, selection) statement_node = search_upwards(origin,ast.stmt) ############################################################### # transformationszooming ################################################################ every_caller = find_all_nodes(root,(ast.Call)) level = LevelVisitor(root,every_caller,atok) lca = LCA(statement_node) def transformation(node): calling_parent, field,field_index = level[node] if not calling_parent or calling_parent is level.root: return None if correspond_to_index_in_call(calling_parent,query_description["level_index"]-1,field,field_index): adj = translate_adjective[query_description["adjective"]]-1 n = level(node, 3,adj) return node if n is node else None else: return None def inverse_transformation(node): return [node] result, alternatives = self.process_line( q = query_description, root = statement_node, atok = atok, origin = origin, select_node = origin if selection[0]!=selection[1] else None, tiebreaker = lambda x: tiebreak_on_lca(statement_node,origin,x), transformation = transformation, inverse_transformation = inverse_transformation ) return self._backward_result(result, alternatives,build)
def handle_single(self, view_information, query_description, extra={}): build, selection, origin = self._preliminary(view_information, query_description, extra) if not build: return None, None root, atok, m, r = build definition_nodes = [ search_upwards(origin, ast.FunctionDef) ] if query_description["format"] == 2 else find_all_nodes( root, ast.FunctionDef) name_nodes = make_flat( [get_argument_from_definition(x) for x in definition_nodes]) names = list(OrderedDict([(x, 0) for x in name_nodes]).keys()) result = names[query_description["collect_index"] - 1] if query_description["format"] == 2 else None return result, names
def handle_single(self, view_information, query_description, extra={}): build, selection, origin = self._preliminary(view_information, query_description, extra) if not build: return None, None root, atok, m, r = build definition_node = search_upwards( origin, ast.FunctionDef) if query_description["format"] == 2 else root name_nodes = [(get_id(x), 0) for x in find_all_nodes(definition_node, ast.Name) if is_store(x)] names = list(OrderedDict(name_nodes).keys()) print(names, "names") result = names[query_description["collect_index"] - 1] if query_description["format"] == 2 else None return result, names
def handle_single(self,view_information,query_description,extra = {}): build, selection, origin = self._preliminary(view_information,query_description,extra) if not build: return None,None root,atok,m,r = build definition_node = search_upwards(origin,ast.FunctionDef) if query_description["format"]!=1 else root name_nodes = [(get_id(x),0) for x in find_all_nodes(definition_node,ast.Name) if is_store(x)] names = list(OrderedDict(name_nodes).keys()) if query_description["format"]==1: result = None else: mode = { 2:"individual", 3:"range", }[query_description["format"]] result = ",".join(decode_item_selection(names,query_description,mode,"item_index")) return result, names
def case_one(self,view_information,query_description, extra = {}): ################################################################ # <adjective> argument <argument_index> ############################################################### selection = self._get_selection(view_information,extra) build = self.general_build if self.general_build else line_partial(selection[0]) if not build or not build[0] : return None,None root,atok,m,r = build selection = m.forward(selection) origin = nearest_node_from_offset(root,atok, selection[0]) if selection[0]==selection[1] else node_from_range(root,atok, selection) statement_node = search_upwards(origin,ast.stmt) result, alternatives = self.process_line( q = query_description, root = statement_node, atok = atok, origin = origin, select_node = origin if selection[0]!=selection[1] else None, tiebreaker = lambda x: tiebreak_on_lca(statement_node,origin,x) ) return self._backward_result(result, alternatives,build)
def case_one(self, v, q): """ <adjective> argument <argument_index> """ selection = v["selection"] build = self.general_build if self.general_build else line_partial( selection[0]) print(build) if not build: return None, None root, atok, m, r = build selection = m.forward(selection) # after build we set up some variables result = None alternatives = None origin = nearest_node_from_offset(root, atok, selection[0]) calling_node = search_upwards(origin, ast.Call) statement_node, callers = search_upwards_log(origin, ast.stmt, log_targets=ast.Call) information = lambda x: info.get_argument_from_call( x, q["argument_index"] - 1) candidates = sorted_by_source_region( atok, find_matching(statement_node, info.identity(information))) every_caller = find_all_nodes(statement_node, (ast.Call)) ################################################################ # if no adjective is given ################################################################ if q["adjective"] == "None": if calling_node: result = information(calling_node) candidates = [ information(x) for x in tiebreak_on_lca(statement_node, origin, candidates) if x != calling_node ] result, alternatives = obtain_result(result, candidates) ################################################################ # adjective is even ################################################################ if q["adjective"] != "None": additional_parameters = {} if selection[0] != selection[1]: small_root = node_from_range(root, atok, selection) additional_parameters["small_root"] = small_root print("dumping the small root\n", ast.dump(small_root)) additional_parameters["special"] = [calling_node] if calling_node: print(ast.dump(calling_node)) additional_parameters["penalized"] = [calling_node] result, alternatives = adjective_strategy( atok=atok, root=root, adjective_word=q["adjective"], level_nodes=every_caller, information_nodes=candidates, **additional_parameters) result = information(result) if result else m.forward( v["selection"]) alternatives = [information(x) for x in alternatives] if alternatives else [] # translate those nodes back to offsets and forward them through the modification under print("\n\nnow finally printing result and alternatives\n\n") print(result) print( ast.dump(result) if isinstance(result, ast.AST ) else " not known node") print(alternatives) result = m.backward(get_source_region(atok, result)) alternatives = [ m.backward(get_source_region(atok, x)) for x in alternatives ] return result, alternatives
def process_line(self, q, root, atok, origin=None, select_node=None, tiebreaker=lambda x: x, line=None, transformation=None, inverse_transformation=None, priority={}, constrained_space=(), second_tiebreaker=None, invert_then_tiebreak=True): result = None alternatives = None additional_parameters = {"priority": priority} if constrained_space: additional_parameters["constrained_space"] = constrained_space information = self.get_information(q) information_nodes = sorted_by_source_region( atok, find_matching(root, information)) if origin: calling_node = search_upwards(origin, ast.Call) statement_node, callers = search_upwards_log(origin, ast.stmt, log_targets=ast.Call) every_caller = find_all_nodes(root, (ast.Call)) additional = find_all_nodes(root, (ast.Tuple, ast.List, ast.ListComp)) if additional: additional_parameters["additional_level_nodes"] = additional additional_parameters["try_alternative"] = True ################################################################ # go to handle the special Casey's ################################################################ if transformation: temporary = {transformation(x) for x in information_nodes} information_nodes = sorted_by_source_region( atok, [x for x in temporary if x]) ################################################################ # if no adjective is given ################################################################ if "nth" not in q: if origin and calling_node: result = calling_node if calling_node in information_nodes else None information_nodes = [ x for x in tiebreaker(information_nodes) if x is not calling_node ] else: result = None information_nodes = [x for x in tiebreaker(information_nodes)] result, alternatives = obtain_result(result, information_nodes) ################################################################ # adjective is given ################################################################ if "nth" in q: additional_parameters["small_root"] = select_node if origin and calling_node: additional_parameters["penalized"] = [ calling_node ] if calling_node else [] additional_parameters["special"] = [calling_node] result, alternatives = adjective_strategy( atok=atok, root=root, adjective_word=q["nth"], level_nodes=every_caller, information_nodes=information_nodes, **additional_parameters) ############################################################## # reverse transformation if any ############################################################## if transformation: helpful = [result] if result else [] if alternatives: helpful.extend(alternatives) if invert_then_tiebreak: temporary = make_flat( [tiebreaker(inverse_transformation(x)) for x in helpful]) else: temporary = tiebreaker( make_flat([inverse_transformation(x) for x in helpful])) result, alternatives = obtain_result(None, temporary) ################################################################ # Extract information ################################################################ if line and result and alternatives: temporary = [result] + alternatives temporary = [(i, x) for i, x in enumerate(temporary)] temporary = sorted( temporary, key=lambda x: (atok._line_numbers.offset_to_line( get_source_region(atok, x[1])[0])[0] != line, x[0])) temporary = [x[1] for x in temporary] result, alternatives = obtain_result(None, temporary) if result and second_tiebreaker: alternatives = second_tiebreaker(result, alternatives) if self.global_constrained_space: inside = lambda x, y: (y[0] <= x[0] < y[1] and y[0] < x[1] <= y[1]) result = result if inside(get_source_region(atok, result), self.global_constrained_space) else None alternatives = [ x for x in alternatives if inside( get_source_region(atok, x), self.global_constrained_space) ] result, alternatives = obtain_result(result, alternatives) result = information(result) if result else None alternatives = [information(x) for x in alternatives] if alternatives else [] return result, alternatives