def maximize_disconnected_pairs(G, k):
tmp = set(G)
nodes = tmp.copy()
node = next(iter(tmp))
tmp.discard(node)
subgraph = nx.subgraph_view(G, filter_node=lambda n: n in tmp)
connectivity = comb(
len(tmp), k) - connectivity_metrics.pairwise_connectivity(subgraph)
vertices = [node]
maximum = connectivity
while tmp:
node = next(iter(tmp))
tmp.discard(node)
nodes.discard(node)
subgraph = nx.subgraph_view(G, filter_node=lambda n: n in nodes)
connectivity = comb(
len(tmp), k) - connectivity_metrics.pairwise_connectivity(subgraph)
if connectivity > maximum:
vertices = [node]
maximum = connectivity
elif connectivity == maximum:
vertices.append(node)
nodes.add(node)
return vertices
def minimize_pairwise_connectivity(G, S0):
tmp = S0.copy()
nodes = tmp.copy()
node = next(iter(tmp))
tmp.discard(node)
subgraph = nx.subgraph_view(G, filter_node=lambda n: n not in tmp)
connectivity = connectivity_metrics.pairwise_connectivity(subgraph)
vertices = [node]
minimum = connectivity
while tmp:
node = next(iter(tmp))
tmp.discard(node)
nodes.discard(node)
subgraph = nx.subgraph_view(G, filter_node=lambda n: n not in nodes)
connectivity = connectivity_metrics.pairwise_connectivity(subgraph)
if connectivity < minimum:
vertices = [node]
minimum = connectivity
elif connectivity == minimum:
vertices.append(node)
nodes.add(node)
return vertices
def interlayer(self, l1, l2=None):
"""return interlayer network for given layer (optional to other layer)"""
if not isinstance(l1, Iterable) and len(self.aspects) == 2:
l1 = (l1,)
else:
l1 = tuple(l1)
if l2 is not None:
if not isinstance(l2, Iterable) and len(self.aspects) == 2:
l2 = (l2,)
else:
l2 = tuple(l2)
interlayer_view = nx.subgraph_view(self, filter_node=lambda n: n[1:] == l1 or n[1:] == l2,
filter_edge=lambda n1, n2: n1[1:] != n2[1:])
else:
interlayer_view = nx.subgraph_view(self, filter_edge=lambda n1, n2: n1[1:] == l1 and n1[1:] != n2[1:])
interlayer_view.aspects = tuple({} for _ in self.aspects)
for n in interlayer_view.nodes:
interlayer_view.aspects[0][n[0]] = self.aspects[0][n[0]]
if l2 is None:
for av, a in zip(interlayer_view.aspects[1:], self.aspects[1:]):
av.update(a)
else:
for i in range(1, len(self.aspects)):
interlayer_view.aspects[i][l1[i-1]] = self.aspects[i][l1[i-1]]
interlayer_view.aspects[i][l2[i-1]] = self.aspects[i][l2[i-1]]
return interlayer_view
def partition(G, sc_weights):
if len(G) <= sc_len:
sc_weights += [G.size(weight='weight')]
return list(G.nodes)
else:
a_nodes, b_nodes = kl(G,
partition=None,
weight='weight',
seed=42,
max_iter=256)
a = nx.subgraph_view(G, filter_node=lambda x: x in a_nodes)
b = nx.subgraph_view(G, filter_node=lambda x: x in b_nodes)
return partition(a, sc_weights) + partition(b, sc_weights)
def get_edge_filtered_subgraph_view(
graph: nx.Graph, query_params: "GraphQueryParams") -> nx.Graph:
"""
Return a subgraph view of input graph according to edge values specified in
the query_dict. Nodes of degree 0 after filtering are removed.
"""
def filter_edge_by_equality(node_start, node_stop):
res = graph[node_start][node_stop].get(query_params.label) \
== query_params.value
return res
def filter_edge_by_inclusion(node_start, node_stop):
res = query_params.value in \
graph[node_start][node_stop].get(query_params.label, [])
return res
if query_params.query_type == 'equality':
filter_edge = filter_edge_by_equality
elif query_params.query_type == 'inclusion':
filter_edge = filter_edge_by_inclusion
res = nx.subgraph_view(graph, filter_edge=filter_edge)
# Keep only nodes of degree > 0 after edge filtering
subgraph_node_names = []
for node_name in res.nodes:
if nx.degree(res, node_name) > 0:
subgraph_node_names.append(node_name)
res = nx.subgraph(res, subgraph_node_names)
return res
def get_participants(network: nx.DiGraph) -> NodeDataView:
def filter_participant(n):
if isinstance(network.nodes[n]["item"], Participant):
return True
return False
view = nx.subgraph_view(network, filter_node=filter_participant)
return view.nodes(data="item")
def graph_layout(edge_lists: List[List[Dict[str, int]]], height_px, width_px):
# lay out connected components, in bounding boxes. then offset
# noinspection PyTypeChecker
g: nx.DiGraph = nx.DiGraph()
for edge_list in edge_lists:
for edge in edge_list:
g.add_edge(edge["source"], edge["target"])
# noinspection PyTypeChecker
components_layouts = [
connected_component_layout(
nx.subgraph_view(
g, filter_node=lambda vertex: vertex in component_vertices))
for component_vertices in nx.weakly_connected_components(g)
]
positions = dict()
corner = np.array([-float(height_px) / 2, -float(width_px) / 2])
running_y = 0.0
for component_pos, geom in components_layouts:
running_y = max(running_y, geom[1])
for node in component_pos:
positions[node] = component_pos[node] + corner
corner += np.array([geom[0] + 1.0, 0])
if corner[0] > 20.0:
corner[0] = 0
corner[1] += running_y
running_y = 0.0
return positions
def filter_view(self, filter_node=nx.classes.filters.no_filter, filter_edge=nx.classes.filters.no_filter):
sg = nx.subgraph_view(self, filter_node=filter_node, filter_edge=filter_edge)
sg.aspects = tuple({} for _ in self.aspects)
for n in sg.nodes:
for i, ni in enumerate(n):
sg.aspects[i][ni] = self.aspects[i][ni]
return sg
def get_pairwise_connectivity(exclude=None):
if exclude is None:
exclude = {}
S = set(exclude)
subgraph = nx.subgraph_view(G, filter_node=lambda n: n not in S)
return connectivity_metric.pairwise_connectivity(subgraph)
def connected_components(exclude=None):
if exclude is None:
exclude = {}
S = set(exclude)
subgraph = nx.subgraph_view(G, filter_node=lambda n: n not in S)
return nx.number_connected_components(subgraph)
def get_zero_weight_subgraph(graph, cost_weight):
"""
Return view of graph with edges whose cost is zero
"""
def filter_edge(n1, n2, k):
return graph.edges[n1, n2, k][cost_weight] == 0
return nx.subgraph_view(graph, filter_edge=filter_edge)
def get_critical_nodes_greedy(G, k):
S = cnp.greedy_cnp(G, k)
subgraph = nx.subgraph_view(G, filter_node=lambda n: n not in S)
fitness = connectivity_metrics.pairwise_connectivity(subgraph)
print(fitness)
return fitness
def get_subgraph(g, edge_filter_func):
"""Get a subgraph of original graph filtered by a provided function."""
logger.info('Getting subgraph with %s function' % edge_filter_func)
view = nx.subgraph_view(g,
filter_edge=functools.partial(edge_filter_func, g))
# Copying to get a graph object instead of view
new_g = view.copy()
return new_g
def get_critical_nodes_ga(G, k):
S, _ = cnp.genetic_algorithm(G, k)
subgraph = nx.subgraph_view(G, filter_node=lambda n: n not in S)
fitness = connectivity_metrics.pairwise_connectivity(subgraph)
print(fitness)
return fitness
def get_participants(network) -> Dict[int, Participant]:
def filter_participant(n):
if isinstance(network.nodes[n]["item"], Participant):
return True
return False
view = nx.subgraph_view(network, filter_node=filter_participant)
return view.nodes(data="item")
def get_edges_by_type(network, edge_type_selection):
def filter_by_type(n1, n2):
if network.edges[(n1, n2)]["type"] == edge_type_selection:
return True
return False
view = nx.subgraph_view(network, filter_edge=filter_by_type)
return view.edges()
def find_substrate_path(self, copied_substrate, vnr, embedding_s_nodes):
embedding_s_paths = {}
directed_copied_substrate = copied_substrate.net.to_directed()
# mapping the virtual nodes and substrate_net nodes
for src_v_node, dst_v_node, edge_data in vnr.net.edges(data=True):
v_link = (src_v_node, dst_v_node)
src_s_node = embedding_s_nodes[src_v_node][0]
dst_s_node = embedding_s_nodes[dst_v_node][0]
v_bandwidth_demand = edge_data['bandwidth']
if src_s_node == dst_s_node:
s_links_in_path = []
embedding_s_paths[v_link] = (s_links_in_path, v_bandwidth_demand)
else:
subnet = nx.subgraph_view(
copied_substrate.net,
filter_edge=lambda node_1_id, node_2_id: \
True if copied_substrate.net.edges[(node_1_id, node_2_id)][
'bandwidth'] >= v_bandwidth_demand else False
)
# Just for assertion
# for u, v, a in subnet.edges(data=True):
# assert a["bandwidth"] >= v_bandwidth_demand
if len(subnet.edges) == 0 or not nx.has_path(subnet, source=src_s_node, target=dst_s_node):
self.num_link_embedding_fails += 1
msg = "VNR {0} REJECTED ({1}): 'no suitable LINK for bandwidth demand: {2} {3}".format(
vnr.id, self.num_link_embedding_fails, v_bandwidth_demand, vnr
)
self.logger.info("{0} {1}".format(utils.step_prefix(self.time_step), msg))
return None
MAX_K = 1
# shortest_s_path = utils.k_shortest_paths(subnet, source=src_s_node, target=dst_s_node, k=MAX_K)[0]
# https://networkx.org/documentation/stable//reference/algorithms/generated/networkx.algorithms.flow.shortest_augmenting_path.html
residual_network = shortest_augmenting_path(directed_copied_substrate, src_s_node, dst_s_node,
capacity='bandwidth',
cutoff=v_bandwidth_demand)
s_links_in_path = []
path = []
for src_r_node, dst_r_node, r_edge_data in residual_network.edges(data=True):
if r_edge_data['flow'] > 0:
s_links_in_path.append((src_r_node, dst_r_node))
# s_links_in_path = []
# for node_idx in range(len(shortest_s_path) - 1):
# s_links_in_path.append((shortest_s_path[node_idx], shortest_s_path[node_idx + 1]))
for s_link in s_links_in_path:
# assert copied_substrate.net.edges[s_link]['bandwidth'] >= v_bandwidth_demand
copied_substrate.net.edges[s_link]['bandwidth'] -= v_bandwidth_demand
embedding_s_paths[v_link] = (s_links_in_path, v_bandwidth_demand)
return embedding_s_paths
def get_direct_nonprivate_graph(self):
"""Get a graph view of direct nonprivate edges."""
def filter_direct_nonprivate_edges(n1, n2):
return (self[n1][n2].get(EdgeProps.direct.name) and
(self[n1][n2].get(EdgeProps.visibility.name) == self.get_deptype('Public') or
self[n1][n2].get(EdgeProps.visibility.name) == self.get_deptype('Interface')))
return networkx.subgraph_view(self, filter_edge=filter_direct_nonprivate_edges)
def collapsed_view(self) -> nx.DiGraph:
outer_nodes = set()
for terminal_uuid in self._parsed_artifact_uuids:
outer_nodes |= self.get_outer_provenance_nodes(terminal_uuid)
def n_filter(node):
return node in outer_nodes
return nx.subgraph_view(self.dag, filter_node=n_filter)
def get_proposals(network, status: ProposalStatus = None):
def filter_proposal(n):
if isinstance(network.nodes[n]["item"], Proposal):
if status:
return network.nodes[n]["item"].status == status
return True
return False
view = nx.subgraph_view(network, filter_node=filter_proposal)
return view.nodes(data="item")
def get_node_tree(self, node):
"""Get a tree with the passed node as the single root."""
direct_nonprivate_graph = self.get_direct_nonprivate_graph()
substree_set = networkx.descendants(direct_nonprivate_graph, node)
def subtree(n1):
return n1 in substree_set or n1 == node
return networkx.subgraph_view(direct_nonprivate_graph, filter_node=subtree)
def get_filtered_graph(graph, filter_node=None, filter_edge=None):
if filter_node:
return nx.subgraph_view(graph, filter_node=filter_node)
elif filter_edge:
return nx.restricted_view(graph, [],
[(n1, n2)
for (n1, n2, attr) in graph.edges(data=True)
if not filter_edge((n1, n2, attr))])
else:
return graph
def decompose_into_chains(problem_instance: dimod.BinaryQuadraticModel):
problem_graph = problem_instance.to_networkx_graph()
for log_qb in problem_graph:
problem_graph.add_node(log_qb, endnode=False)
problem_size = len(problem_graph)
color_sets = find_edge_coloring(problem_graph)
color_sets = sorted(color_sets,
key=lambda color_set: len(color_set),
reverse=True)
for log_qb0, log_qb1 in problem_graph.edges():
if frozenset((log_qb0, log_qb1)) in color_sets[0]:
color0 = problem_graph[log_qb0][log_qb1]['color']
break
for log_qb0, log_qb1 in problem_graph.edges():
if frozenset((log_qb0, log_qb1)) in color_sets[1]:
color1 = problem_graph[log_qb0][log_qb1]['color']
break
def filter_edge(log_qb0, log_qb1) -> bool:
if problem_graph[log_qb0][log_qb1]['color'] == color0:
return True
elif problem_graph[log_qb0][log_qb1]['color'] == color1:
return True
else:
return False
twocolor_graph = nx.subgraph_view(problem_graph, filter_edge=filter_edge)
components = [
twocolor_graph.subgraph(c).copy()
for c in nx.connected_components(twocolor_graph)
]
chains, loops = [], []
for component in components:
deg = 3
for node in component:
if component.degree(node) < deg:
node0 = node
deg = component.degree(node)
for neighbor in component.neighbors(node0):
node1 = neighbor
break
lst = [node0, node1]
for _ in range(len(component) - 2):
for neighbor in component.neighbors(node1):
if neighbor is not node0:
node0 = node1
node1 = neighbor
lst.append(node1)
break
if deg == 1:
chains.append(lst)
elif deg == 2:
loops.append(lst)
return chains, loops
def processes_subgraph_view(self) -> nx.DiGraph:
"""Returns the subgraph view of the :doc:`CBRGraph <cbrg>` including only its
processes.
:return: The processes' subgraph view from the :doc:`CBRGraph <cbrg>`
:rtype: networkx.classes.digraph.DiGraph
"""
def filter_process(node):
return self.g.nodes[node]["type"] == "cbp"
return nx.subgraph_view(self.g, filter_node=filter_process)
def get_edges_by_type(network: nx.DiGraph,
edge_type_selection: str,
participant_idx: int = None):
def filter_by_type(n1, n2):
if (participant_idx is None or n1 == participant_idx
) and network.edges[(n1, n2)]["type"] == edge_type_selection:
return True
return False
view = nx.subgraph_view(network, filter_edge=filter_by_type)
return view.edges()
def extract_subclaims(self):
# Convert graphviz to networkx.
G = nx.nx_pydot.from_pydot(graph_from_dot_data(self.graph.source)[0])
claims_list = []
subtrees = []
# Find the subclaim roots - the verbs that the conjunction of implies the documents root.
subtree_roots = list(p[0] for p in G.in_edges(
nbunch=self.argID(self.doc[:]))) # Store the subclaim graph roots
H = nx.subgraph_view(
G, filter_node=(lambda n: n != self.argID(self.doc[:]))
) # Create a view without the overall text/main root.
# After removing the root, should have 1+ connected components. If a cycle is detected when trying to find them,
# remove the last edge that caused it (this rarely happens in practice).
cycling = True
while cycling:
try:
# Create the subclaim graphs - once detaching the whole-text root these are connected components
subtrees = [
H.subgraph(c).copy()
for c in nx.weakly_connected_components(H)
]
except nx.HasACycle:
G.remove_edge(nx.find_cycle(G)[-1])
else:
cycling = False
# Create a Claim object for each component.
for subclaim in subtrees:
# take all roots that form this subclaim (could be multiple if they're connected - this makes the 'tree' not
# strictly a 'tree').
rel_roots = list(filter(lambda x: x in subclaim, subtree_roots))
removed_edges, removed_nodes = [], []
# Outbound edges from roots are nearly always erroneous, so they are removed as soon as possible:
# Also remove any cases of nodes that have entirely dashed input.
for j in rel_roots:
for i in subclaim.out_edges(j):
removed_edges.append((i[0], i[1]))
for i2 in subclaim.nodes():
if len(subclaim.in_edges(i2)) and all(
x[2].get('style', '') == 'dotted'
for x in subclaim.in_edges(i2, data=True)):
removed_nodes.append(i2)
subclaim.remove_nodes_from(removed_nodes)
subclaim.remove_edges_from(removed_edges)
claims_list.append(Claim(self, subclaim, rel_roots))
return claims_list
def get_tags(self, repository):
def _filter(node):
n = self.graph.nodes[node]
if n[ATTR_TYPE] != TYPE_TAG:
return False
if n[ATTR_REPOSITORY] != repository:
return False
return True
tags = subgraph_view(self.graph, _filter)
resolved_tags = [tags.nodes[tag][ATTR_TAG] for tag in tags.nodes]
if len(resolved_tags) == 0:
raise KeyError()
return resolved_tags
def _update(G, best_S, P, alpha):
subgraph = nx.subgraph_view(G, filter_node=lambda n: n not in best_S)
metric = connectivity_metric.pairwise_connectivity(subgraph)
avg = 0
for S in P:
avg += len(S.intersection(best_S))
avg /= len(P)
try:
gamma = (alpha * metric) / avg
except:
gamma = 1
return gamma
def g(G, partition_list, args):
result = 0
partition_size = default_size
if args.weighted_size:
partition_size = weighted_size
for p in partition_list:
n_partitions = len(partition_list)
p_view = nx.subgraph_view(G, filter_node=lambda n: n in p)
p_view = p_view.to_undirected()
cost = num_edges_in_partition(G, p) - \
partition_cost(args, G, n_partitions, partition_size(args, G, p), partition_size(args, G, G))
result += cost
return result
def find_all_s_paths_2(copied_substrate, embedding_s_nodes, vnr):
all_s_paths = {}
# 각 v_link 당 가능한 모든 s_path (set of s_link) 구성하여 all_s_paths에 저장
for src_v_node, dst_v_node, edge_data in vnr.net.edges(data=True):
v_link = (src_v_node, dst_v_node)
src_s_node = embedding_s_nodes[src_v_node][0]
dst_s_node = embedding_s_nodes[dst_v_node][0]
v_bandwidth_demand = edge_data['bandwidth']
if src_s_node == dst_s_node:
all_s_paths[v_link][0] = ([], v_bandwidth_demand)
else:
subnet = nx.subgraph_view(
copied_substrate.net,
filter_edge=lambda node_1_id, node_2_id: \
True if copied_substrate.net.edges[(node_1_id, node_2_id)]['bandwidth'] >= v_bandwidth_demand else False
)
if len(subnet.edges) == 0 or not nx.has_path(
subnet, source=src_s_node, target=dst_s_node):
return False, (v_link, v_bandwidth_demand)
all_paths = nx.all_simple_paths(
subnet,
source=src_s_node,
target=dst_s_node,
cutoff=config.MAX_EMBEDDING_PATH_LENGTH)
all_s_paths[v_link] = {}
s_path_idx = 0
for path in all_paths:
s_links_in_path = []
for node_idx in range(len(path) - 1):
s_links_in_path.append(
(path[node_idx], path[node_idx + 1]))
all_s_paths[v_link][s_path_idx] = (s_links_in_path,
v_bandwidth_demand)
s_path_idx += 1
if s_path_idx == 0:
return False, (v_link, None)
return True, all_s_paths
