def fix_argument_list(root, atok):
if not match_node(root, ast.arguments):
return False
if already_fixed(root) or match_node(root.parent,
(ast.FunctionDef)) and fix_definition(
root.parent, atok):
return True
return False
def get_arg_from_definition(root, atok):
if not match_node(root, ast.arg):
if match_node(root, ast.FunctionDef):
fix_definition(root, atok)
return None
if match_parent(root, ast.FunctionDef):
fix_definition(root.parent, atok)
elif match_parent(root.parent, ast.FunctionDef):
fix_definition(root.parent.parent, atok)
else:
return None
return root
def get_raw(root): return ( root.n if match_node(root,(ast.Num)) else root.s if match_node(root,(ast.Str,ast.Bytes )) else root.value if match_node(root,(ast.NameConstant)) else root.id if match_node(root,(ast.Name )) else get_raw(root.func) if match_node(root,(ast.Call )) else root.arg if match_node(root,(ast.keyword)) else root.attr+"."+get_raw(root.value) if match_node(root,(ast.Attribute )) else get_raw(root.value) if match_node(root,(ast.Subscript,ast.Index )) else (get_raw(root.type),root.name) if match_node(root,(ast.ExceptHandler)) else root.name if match_node(root,(ast.FunctionDef)) else None )
def is_of_higher_priority(parent_node,child_node):
operator_priority = [
ast.BitOr,ast.BitXor, ast.BitAnd,
(ast.LShift,ast.RShift),(ast.Add,ast.Sub),
(ast.Mult, ast.Div, ast.FloorDiv, ast.Mod) ,
ast.Pow,
]
print(ast.dump(parent_node),parent_node.op)
for operator in operator_priority:
p = match_node(parent_node.op, operator)
c = match_node(child_node.op, operator)
print("\ntesting operator ",operator,p,c,"\n")
if p and not c:
return True
return False
def fix_argument(root, atok, token=None):
if already_fixed(root):
return token
# the following check was introduced to work around issue #17
if not match_node(root.parent.parent, ast.FunctionDef):
return None
if token is None:
fix_definition(root.parent.parent, atok)
if not already_fixed(root):
raise Exception("these ARG node has not been marked as fixed")
return None
mark_fixed(root)
root.first_token = token
fake_node = create_fake(root,
ast.Name,
real_tokens=token,
id=token.string,
ctx=ast.Load())
set_fake(root, "arg", fake_node)
if getattr(root, "annotation", False):
root.last_token = root.annotation.last_token
return root.annotation.last_token
else:
root.last_token = token
return token
def get_class_name(root, atok):
if not match_node(root, ast.ClassDef):
return None
if not already_fixed(root):
generic_fix(root, atok)
assert already_fixed(root), "Class Name has not been fixed"
return get_fake(root, "name")
def get_definition_parameter_name(root, atok):
if not match_node(root, ast.arg):
return None
if not already_fixed(root):
generic_fix(root, atok)
assert already_fixed(root), "Arg has not been fixed"
return get_fake(root, "arg")
def get_definition_name(root, atok):
if not match_node(root, ast.FunctionDef):
return None
if not already_fixed(root):
generic_fix(root, atok)
assert already_fixed(root), "Definition has not been fixed"
return get_fake(root, "name")
def get_boolean_middle(root):
if not match_node(root, ast.BoolOp) or match_parent(root, ast.BoolOp):
return None
items = root.values
if len(items) == 3:
return items[1]
return None
def get_boolean_right(root):
if not match_node(root, ast.BoolOp) or match_parent(root, ast.BoolOp):
return None
items = root.values
if len(items) >= 2:
return items[-1]
return None
def get_arithmetic_middle(root):
if not match_node(root, ast.BinOp) or match_parent(root, ast.BinOp):
return None
items = get_sub_index(root, None)
if len(items) == 3:
return items[1]
return None
def get_arithmetic_right(root):
if not match_node(root, ast.BinOp) or match_parent(root, ast.BinOp):
return None
items = get_sub_index(root, None)
if len(items) >= 2:
return items[-1]
return None
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={}):
################################################################
# <adjective> <big_roi>
###############################################################
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
additional_parameters = {}
if selection[0] != selection[1]:
additional_parameters["small_root"] = origin
additional_parameters["penalized"] = [origin]
additional_parameters["only_information"] = True
# just looking on the shape of this code you know there's a bug in here somewhere:)
result, alternatives = adjective_strategy(
atok=atok,
root=definition_node,
adjective_word=query_description["nth"],
level_nodes=find_all_nodes(
definition_node, (ast.If, ast.While, ast.For, ast.Try,
ast.With, ast.FunctionDef, ast.ClassDef)),
information_nodes=find_matching(definition_node,
temporary_information),
**additional_parameters)
print("result, alternatives", result, alternatives, "\n")
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 get_keyword_argument(root,index = None,only_value = True): temporary = root.keywords if match_node(root,(ast.Call )) else None temporary = [x.value for x in temporary if only_value] if temporary else None return ( (temporary[index] if index and len(temporary)>index else temporary) if temporary else None )
def case_four(self, view_information, query_description, extra={}):
################################################################
# [smart] <vertical_abstract_only_direction> [<ndir>] <block> [<adjective>] <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)
temporary_information = lambda x: match_node(x, ast.FunctionDef)
root, atok, m, r = build
direction = query_description["vertical_direction"]
ndir = query_description["ndir"]
row = view_information["rowcol"](
m.backward(selection)[0]
)[0] + 1 if definition_node is root 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, targets, row, ndir + bonus,
direction, True, temporary_information)
if "nth" not in query_description:
information = getattr(information, "secondary", information)
selector = lambda x: match_node(x, targets, exclusions
) and generic_fix(x, build[1])
candidates = tiebreak_on_lca(root, definition_node,
find_all_nodes(t, selector=selector))
candidates = [information(x) for x in candidates if information(x)]
result, alternatives = obtain_result(None, candidates)
return self._backward_result(result, alternatives, build)
else:
additional_parameters = {}
result, alternatives = adjective_strategy(
atok=atok,
root=t,
adjective_word=query_description["nth"],
level_nodes=find_all_nodes(
t, (ast.If, ast.While, ast.For, ast.Try, ast.With,
ast.FunctionDef)),
information_nodes=find_matching(
t, lambda x: information(x)
if match_node(x, targets, exclusions) else None),
**additional_parameters)
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 get_subparts_of_binary_operation(root): left = ( [root.left] if not match_node(root.left,ast.BinOp) or is_of_higher_priority(root,root.left) else get_subparts_of_binary_operation(root.left) ) right = [root.right] return left + right
def get_decorator_text(root, atok, everything):
if not is_decorator(root):
return None
if everything:
return atok.get_text(root)
else:
if match_node(root, ast.Call):
return atok.get_text(root.func)
def get_module(root, atok):
if not match_node(root, (ast.Import, ast.ImportFrom)):
return None
if not already_fixed(root):
fix_import(root, atok)
assert already_fixed(
root), "inside get_module I received an node that is not fixed"
return get_fake(root, "module")
def get_subparts_of_attribute(root):
if not match_node(root, ast.Attribute):
return None
l = root.last_token
if already_fixed(root):
fake_node = get_fake(root, "attr")
else:
fake_node = create_fake(root,
ast.Name,
text=l.string,
start_position=l.startpos,
id=l.string,
ctx=root.ctx)
if match_node(root.value, ast.Attribute):
return get_subparts_of_attribute(root.value) + [fake_node]
else:
return [root.value, fake_node]
def node_from_range_new(root, atok, r, special=False, lenient=False):
# notes like ast.Store result in (0,0) with atok.get_text_range()
# which causes problems if the cursor is right at the beginning of the file
inside = lambda x, y: (y[0] <= x[0] < y[1] and y[0] < x[1] <= y[1] and
not y[0] == y[1] == 0)
if lenient:
inside = lambda x, y: (y[0] <= x[0] <= y[1] and y[0] <= x[1] <= y[1]
and not y[0] == y[1] == 0)
generic_fix(root, atok)
for child in ast.iter_child_nodes(root):
# print(" just to check something out",child,atok.get_text_range(child))
# print(" and the child fields are ",child._fields)
if inside(r, atok.get_text_range(child)):
# print(" success with",child,"special = ",special)
return node_from_range_new(child, atok, r, special, lenient)
if special:
# print("Special:\n",ast.dump(root))
if match_node(root,
(ast.Tuple, ast.List, ast.Set, ast.Dict, ast.DictComp)):
# print("Inside Here After Special")
temporary = get_sub_index(root, None)
l = [
x for x in temporary for y in [get_source_region(atok, x)]
if inside((r[0], r[0]), y) or inside((
r[1], r[1]), y) or inside(y, r)
]
# print("temporary:\n",temporary)
# print("L:\n",l)
if l and l != temporary:
return l
if match_node(root, (ast.FunctionDef, ast.ClassDef)):
converter = atok._line_numbers
sr, sc = converter.offset_to_line(r[0])
er, ec = converter.offset_to_line(r[1])
for decorator in root.decorator_list:
if sr != decorator.first_token.start[0]:
continue
if er != decorator.last_token.start[0]:
if er != decorator.last_token.start[0] + 1 or ec != 0:
continue
return decorator
return root
def get_argument_from_definition(root,raw = True,index = None): if not match_node(root,ast.FunctionDef): return None x= root.args temporary = x.args + [x.vararg] + x.kwonlyargs + [x.kwarg] temporary = [y for y in temporary if y] if raw: temporary = [(y.arg if isinstance(y,ast.AST) else y) for y in temporary] return temporary[index] if (index is not None) and len(temporary)>index else temporary
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 tiebreaker(x):
depth, node = lca(x, origin, node_and_depth=True)
v = 3
if match_node(node, ast.Dict):
if node is not x and node is not origin:
field, field_index = lca.get_field_with_respect_to(x, node)
ofield, ofield_index = lca.get_field_with_respect_to(
origin, node)
v = abs(field_index - ofield_index)
v = v if v < 3 else 3
return (-1 * depth, v, lca.get_depth(x),
abs(x.first_token.start[0] - origin.first_token.start[0]))
def get_argument_from_empty_call(root):
if not match_node(root, (ast.Call)):
return None
if get_argument_from_call(root, 0):
return None
return create_fake(root,
ast.Name,
text="",
start_position=root.last_token.startpos,
parent=root,
parent_field="args")
def get_keyword_argument(root,
index=None,
only_value=True,
only_keyword=False):
temporary = root.keywords if match_node(root, (ast.Call)) else None
if only_value and not only_keyword:
temporary = [x.value for x in temporary] if temporary else None
elif only_keyword:
temporary = [
get_fake(x, "arg") for x in temporary if generic_fix(x, None)
] if temporary else None
return ((temporary[index] if index is not None and len(temporary) > index
else temporary) if temporary else None)
def get_argument_from_call(root, index):
if not match_node(root,(ast.Call)):
return None
temporary = [
get_positional_argument(root,None),
get_keyword_argument(root,None, True),
[get_star_argument(root,None)],
[get_keyword_star_argument(root,None)]
]
temporary = make_flat([x for x in temporary if x])
temporary = [x for x in temporary if x]
temporary = sorted(temporary,key= lambda x:x.first_token.startpos)
# print(" I would regret face", temporary)
return temporary[index] if temporary and len(temporary)>index else None
def fix_attribute(root, atok):
if already_fixed(root):
return True
l = root.last_token
fake_node = create_fake(root,
ast.Name,
real_tokens=l,
parent=root,
parent_field="attr",
id=l.string,
ctx=root.ctx)
set_fake(root, "attr", fake_node)
if match_node(root.value, ast.Attribute):
fix_attribute(root.value, atok)
mark_fixed(root)
def get_weak_header(root, atok):
return (root.test if match_node(root, (ast.While, ast.If)) else
root.arguments if match_node(root, (ast.FunctionDef)) else
[root.target, root.iter] if match_node(root,
(ast.For)) else root.bases +
root.keywords if match_node(root, (
ast.ClassDef)) else root.items if match_node(root, (
ast.With
)) else root.type if match_node(root,
(ast.ExceptHandler)) else None)
