in src/graph_notebook/network/gremlin/GremlinNetwork.py [0:0]
def add_results_with_pattern(self, results, pattern_list: list):
"""
Allow an expression of a path pattern along with results to help parse the direction a path is flowing.
Valid patterns are V, inV, outV, E, inE, outE. No two edges may be adjacent, however, two vertices can be.
This alternate way of parsing results is to prevent the behavior of an edge which is represented by string
being unable to be discerned from a node, leading to a rendered query showing blank edges with an intermediary
node originally meant to be an edge label. For example:
g.V().outE().inV().path().by('code').by('dist')
The above will give back something such as:
=> path[FLL, 982, BQN]
We want 982 to show as the label between FLL and BQN. For this, we could use the pattern V,outE,inV
:param results: The list of path results
:param pattern_list: The list of patterns to be used in order while traversing a path
:return:
"""
if not isinstance(results, list):
raise ValueError("results must be a list of paths")
for path in results:
if not isinstance(path, Path):
raise ValueError("all entries in results must be paths")
if type(path[0]) is Edge or type(path[-1]) is Edge:
raise INVALID_PATH_ERROR
path_index = 0
while path_index < len(path):
for i in range(len(pattern_list)):
if path_index >= len(path):
break
path_pattern = pattern_list[i]
previous_pattern = pattern_list[i - 1] if i != 0 else pattern_list[-1]
next_pattern = pattern_list[i + 1] if i < len(pattern_list) - 1 else pattern_list[0]
current_node_id = str(get_id(path[path_index]))
try:
prev_node_id = str(get_id(path[path_index - 1]))
except IndexError:
prev_node_id = None
try:
next_node_id = str(get_id(path[path_index + 1]))
except IndexError:
next_node_id = None
# the current pattern is V, inV, or outV
if path_pattern in V_PATTERNS:
# we cannot reconcile an edge type with a node
if type(path[path_index]) is Edge:
raise INVALID_VERTEX_PATH_PATTERN_ERROR
# add the vertex, no matter what patterns border a vertex pattern, it will always be added.
self.add_vertex(path[path_index], path_index=i)
# if the path index is over 0, we need to handle edges between this node and the previous one
if path_index > 0:
if path_pattern == PathPattern.V:
# two V patterns next to each other is an undirected, unlabeled edge
if previous_pattern == PathPattern.V:
self.add_blank_edge(prev_node_id,
current_node_id,
undirected=True)
# IN_V -> V will draw an outgoing edge from the current element to the previous one.
elif previous_pattern == PathPattern.IN_V:
self.add_blank_edge(path[path_index], path[path_index - 1], undirected=False)
# OUT_V -> V will draw an outgoing edge from the previous element to the current one.
elif previous_pattern == PathPattern.OUT_V:
self.add_blank_edge(path[path_index - 1], path[path_index], undirected=False)
# path_pattern (IN_V) <- previous_pattern (V, OUT_V)
elif path_pattern == PathPattern.IN_V and previous_pattern not in E_PATTERNS:
# draw an unlabeled, directed edge from previous -> current
# we can only process V and OUT_V as no two adjacent vertices can both be incoming.
if (previous_pattern == PathPattern.V or PathPattern.OUT_V) and path_index > 0:
self.add_blank_edge(prev_node_id, current_node_id, undirected=False)
else:
raise SAME_DIRECTION_ADJACENT_VERTICES
# path_pattern (OUT_V) -> previous_pattern (V, IN_V)
elif path_pattern == PathPattern.OUT_V and previous_pattern not in E_PATTERNS:
# draw an unlabeled, directed edge from current -> previous
# we can only process V and IN_V as no two adjacent vertices can both be outgoing.
if (previous_pattern == PathPattern.V or PathPattern.IN_V) and path_index > 0:
self.add_blank_edge(current_node_id, prev_node_id, undirected=False)
else:
raise SAME_DIRECTION_ADJACENT_VERTICES
elif path_pattern in E_PATTERNS:
# if the type of the given path element is not Edge,
# draw an undirected edge using this element for edge data
edge = path[path_index]
if path_pattern == PathPattern.E:
# V -> V where the Vertex pattern is identical on either side of the edge
if next_pattern == previous_pattern:
# this is only valid if both are V, two connected vertices cannot have same direction
if next_pattern == PathPattern.V:
self.add_path_edge(edge, prev_node_id, next_node_id, UNDIRECTED_EDGE)
else:
raise SAME_DIRECTION_ADJACENT_VERTICES
# IN_V -> E -> V
elif previous_pattern == PathPattern.IN_V:
self.add_path_edge(edge, next_node_id, prev_node_id)
# OUT_V -> E -> V
elif previous_pattern == PathPattern.OUT_V:
self.add_path_edge(edge, prev_node_id, next_node_id)
# If the edge direction is specified, use it as the source of truth
elif path_pattern == PathPattern.IN_E:
self.add_path_edge(edge, from_id=next_node_id, to_id=prev_node_id)
elif path_pattern == PathPattern.OUT_E:
self.add_path_edge(edge, from_id=prev_node_id, to_id=next_node_id)
else:
raise INVALID_PATH_ERROR
path_index += 1
return