def handle_single(self, view_information, query_description, extra={}):
state = extra["state"]
candidates = result_alternatives_sequence(state, location=True)
if query_description["format"] == 1:
if state["mode"] == "single":
selection = [
candidates[query_description["color" + i]]
for i in ["", "2", "3", "4"]
if "color" + i in query_description
]
selection = selection if isinstance(selection,
list) else [selection]
elif state["mode"] == "multiple":
try:
print("candidates", candidates, "\n")
selection = [
x[query_description["color" + i]] for x in candidates
for i in ["", "2", "3", "4"]
if "color" + i in query_description
]
except IndexError as e:
raise Exception(
"tried to obtain an alternative color that is not common!"
)
if any(isinstance(x, list) for x in selection):
print("inside here the selection has become ", selection)
selection = make_flat(
[x if isinstance(x, list) else [x] for x in selection])
print(
"inside here the selection has become after wardsit's",
selection)
selection = self.filter_overlapping(selection)
print("selection is ", selection, "\n")
return [(x, "") for x in selection]
def find_information(root, information, flatten=False, visit_all_levels=True):
reachable = ast.walk if visit_all_levels else ast.iter_child_nodes
initial_result = [
information(node) for node in reachable(root)
if information(node) is not None
]
return make_flat(initial_result) if flatten else initial_result
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 handle_single(self, view_information, query_description, extra={}):
state = extra["state"]
# print("state:\n",state)
candidates = result_alternatives_sequence(state, location=True)
# print("candidates:\n",candidates)
if "alternative_index" in query_description:
name = "alternative_index"
elif "color" in query_description:
name = "color"
else:
return None, None
if state["mode"] == "single":
result = decode_item_selection(candidates,
query_description,
"individual",
name,
decrement=False)
if len(result) == 1:
result = result[0]
else:
result = [
decode_item_selection(x,
query_description,
"individual",
name,
decrement=False) for x in candidates
]
selection = self._get_selection(view_information, extra)
if not isinstance(selection, list) or len(selection) == 1:
try:
result = make_flat(result)
except:
pass
# print("result is ",result)
return result, []
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 = find_all_nodes(root, (ast.Import, ast.ImportFrom))
name_nodes = make_flat(
[get_imported_value_names(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, origin, selection = self._preliminary(view_information,query_description,extra)
if not build:
return None,None
root,atok,m,r = build
definition_nodes = find_all_nodes(root,(ast.Import,ast.ImportFrom))
name_nodes = make_flat([get_module_names(x) for x in definition_nodes])
for name in name_nodes:
smaller = name.split(".")
if len( smaller)>1:
name_nodes.append(".".join(smaller[:-1]))
names = list(OrderedDict([(x,0) for x in name_nodes]).keys())
result = None
return names
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 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 split_string(s,even_letters = True):
s = s.strip()
y = urlparse(s)
if not (y.scheme=="" and y.netloc==""):
return [z for z in make_flat( [split_string(x,False) for x in y ]) if z]
first_attempt = [x for x in re.split("[., :/]",s) if not x.isspace()]
if len(first_attempt) > 1:
return first_attempt
second_attempt = [x for x in re.split("[_]",s) if not x.isspace()]
if len(second_attempt) > 1:
return second_attempt
# https://stackoverflow.com/questions/29916065/how-to-do-camelcase-split-in-python answer from Jossef Harush
third_attempt = re.sub('([A-Z][a-z]+)', r' \1', re.sub('([A-Z]+)', r' \1', s)).split()
if len(third_attempt) > 1:
return third_attempt
return list(s) if even_letters else [s]
def convert_multiple_to_single(state,mode,initial_mode,lenient = False):
names = []
if mode == "single":
names = names + ["result","origin","alternatives"]
if initial_mode == "single":
names = names + ["initial_origin"]
for k in names:
data = state[k]
if k not in ["alternatives"]:
if data == []:
data = None
elif isinstance(data,list) and len(data)==1 and isinstance(data[0],list) and len(data[0])==1:
data = data[0][0]
else:
if lenient:
pass
else:
raise Exception("when converting from multiple mode In single_mode "+k+" cannot be a nested list!")
else:
if isinstance(data,list) and len(data)==1:
data = make_flat(data)
else:
raise Exception(" when converting into single mode, each of the items in the alternatives must have length of one")
state[k] = data
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
