hSrSSKJr SSKJr SSKrSSKJrJ r /SQr Sr S4Sjr S5S jr S rS rS rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrS6Sjr S4Sjr!S4Sjr"SS.S jr#S4S!jr$S4S"jr%SS#.S$jr&S%r'S&r(S'r)\"S(5S)5r*S7S+jr+\RX"S*S,9S7S-j5r-S.r.S/r/S8S0jr0S1r1S2r2S3r3g)9z=Functional interface to graph methods and assorted utilities.)Counter)chainN)not_implemented_forpairwise)'nodesedgesdegreedegree_histogram neighborsnumber_of_nodesnumber_of_edgesdensity is_directedfreeze is_frozensubgraphinduced_subgraph edge_subgraphrestricted_view to_directed to_undirectedadd_staradd_path add_cyclecreate_empty_copyset_node_attributesget_node_attributesremove_node_attributesset_edge_attributesget_edge_attributesremove_edge_attributes all_neighbors non_neighbors non_edgescommon_neighbors is_weightedis_negatively_weightedis_emptyselfloop_edgesnodes_with_selfloopsnumber_of_selfloops path_weightis_pathc"UR5$)zsReturns a NodeView over the graph nodes. This function wraps the :func:`G.nodes ` property. )rGs K/var/www/html/env/lib/python3.13/site-packages/networkx/classes/function.pyrr4s 779c$URU5$)zReturns an edge view of edges incident to nodes in nbunch. Return all edges if nbunch is unspecified or nbunch=None. For digraphs, edges=out_edges This function wraps the :func:`G.edges ` property. )rr0nbunchs r1rr<s 776?r2c$URX5$)zReturns a degree view of single node or of nbunch of nodes. If nbunch is omitted, then return degrees of *all* nodes. This function wraps the :func:`G.degree ` property. )r )r0r5weights r1r r Hs 88F ##r2c$URU5$)zReturns an iterator over all neighbors of node n. This function wraps the :func:`G.neighbors ` function. )r )r0ns r1r r Qs ;;q>r2c"UR5$)zReturns the number of nodes in the graph. This function wraps the :func:`G.number_of_nodes ` function. )r r/s r1r r Y   r2c"UR5$)zReturns the number of edges in the graph. This function wraps the :func:`G.number_of_edges ` function. )r r/s r1r r ar;r2c[U5n[U5nUS:XdUS::agX!US- -- nUR5(dUS-nU$)aReturns the density of a graph. The density for undirected graphs is .. math:: d = \frac{2m}{n(n-1)}, and for directed graphs is .. math:: d = \frac{m}{n(n-1)}, where `n` is the number of nodes and `m` is the number of edges in `G`. Notes ----- The density is 0 for a graph without edges and 1 for a complete graph. The density of multigraphs can be higher than 1. Self loops are counted in the total number of edges so graphs with self loops can have density higher than 1. r)r r r)r0r9mds r1rrisQ2 AAAva !a%[A ==?? Q Hr2c[SUR555n[U(a[U5S-OS5Vs/sHo!R US5PM sn$s snf)a>Returns a list of the frequency of each degree value. Parameters ---------- G : Networkx graph A graph Returns ------- hist : list A list of frequencies of degrees. The degree values are the index in the list. Notes ----- Note: the bins are width one, hence len(list) can be large (Order(number_of_edges)) c3*# UH upUv M g7fN).0r9rAs r1 #degree_histogram..s.:41Q:sr>r)rr rangemaxget)r0countsis r1r r sN&.188:. .F&+vCK!O1&M N&MJJq! &M NN NsA!c"UR5$)z!Return True if graph is directed.)rr/s r1rrs ==?r2c.[R"S5e)zCDummy method for raising errors when trying to modify frozen graphszFrozen graph can't be modified)nx NetworkXError)argskwargss r1frozenrTs  ; <>> G = nx.path_graph(4) >>> G = nx.freeze(G) >>> try: ... G.add_edge(4, 5) ... except nx.NetworkXError as err: ... print(str(err)) Frozen graph can't be modified Notes ----- To "unfreeze" a graph you must make a copy by creating a new graph object: >>> graph = nx.path_graph(4) >>> frozen_graph = nx.freeze(graph) >>> unfrozen_graph = nx.Graph(frozen_graph) >>> nx.is_frozen(unfrozen_graph) False See Also -------- is_frozen T) rTadd_nodeadd_nodes_from remove_noderemove_nodes_fromadd_edgeadd_edges_fromadd_weighted_edges_from remove_edgeremove_edges_fromclear clear_edgesr/s r1rrscFAJAAM AAJA &AAM AAGAMAH Hr2c<UR$![a gf=f)zoReturns True if graph is frozen. Parameters ---------- G : graph A NetworkX graph See Also -------- freeze F)rTAttributeErrorr/s r1rrs"xx s  c ^[U5n[U5mURT5 U4SjU5nUR"U40UD6 g![a gf=f)aAdd a star to Graph G_to_add_to. The first node in `nodes_for_star` is the middle of the star. It is connected to all other nodes. Parameters ---------- G_to_add_to : graph A NetworkX graph nodes_for_star : iterable container A container of nodes. attr : keyword arguments, optional (default= no attributes) Attributes to add to every edge in star. See Also -------- add_path, add_cycle Examples -------- >>> G = nx.Graph() >>> nx.add_star(G, [0, 1, 2, 3]) >>> nx.add_star(G, [10, 11, 12], weight=2) Nc3,># UH nTU4v M g7frDrE)rFr9vs r1rGadd_star..s #UaVU)iternext StopIterationrVr[) G_to_add_tonodes_for_starattrnlistrres @r1rrs^2  E K #U #Eu-- s A AAc [U5n[U5nURU5 UR"[ [ U4U5540UD6 g![a gf=f)aAdd a path to the Graph G_to_add_to. Parameters ---------- G_to_add_to : graph A NetworkX graph nodes_for_path : iterable container A container of nodes. A path will be constructed from the nodes (in order) and added to the graph. attr : keyword arguments, optional (default= no attributes) Attributes to add to every edge in path. See Also -------- add_star, add_cycle Examples -------- >>> G = nx.Graph() >>> nx.add_path(G, [0, 1, 2, 3]) >>> nx.add_path(G, [10, 11, 12], weight=7) NrhrirjrVr[rr)rknodes_for_pathrmrn first_nodes r1rrsa.  E%[ $xzmU(CDMM s A AAc [U5n[U5nURU5 UR"[ [ U4U5SS940UD6 g![a gf=f)a(Add a cycle to the Graph G_to_add_to. Parameters ---------- G_to_add_to : graph A NetworkX graph nodes_for_cycle: iterable container A container of nodes. A cycle will be constructed from the nodes (in order) and added to the graph. attr : keyword arguments, optional (default= no attributes) Attributes to add to every edge in cycle. See Also -------- add_path, add_star Examples -------- >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc >>> nx.add_cycle(G, [0, 1, 2, 3]) >>> nx.add_cycle(G, [10, 11, 12], weight=7) NT)cyclicrp)rknodes_for_cyclermrnrrs r1rr4si.  !E%[ $ }e,T:>B s A AAc$URU5$)aReturns the subgraph induced on nodes in nbunch. Parameters ---------- G : graph A NetworkX graph nbunch : list, iterable A container of nodes that will be iterated through once (thus it should be an iterator or be iterable). Each element of the container should be a valid node type: any hashable type except None. If nbunch is None, return all edges data in the graph. Nodes in nbunch that are not in the graph will be (quietly) ignored. Notes ----- subgraph(G) calls G.subgraph() )rr4s r1rrVs( ::f r2c[RRURU55n[R"XS9$)aYReturns a SubGraph view of `G` showing only nodes in nbunch. The induced subgraph of a graph on a set of nodes N is the graph with nodes N and edges from G which have both ends in N. Parameters ---------- G : NetworkX Graph nbunch : node, container of nodes or None (for all nodes) Returns ------- subgraph : SubGraph View A read-only view of the subgraph in `G` induced by the nodes. Changes to the graph `G` will be reflected in the view. Notes ----- To create a mutable subgraph with its own copies of nodes edges and attributes use `subgraph.copy()` or `Graph(subgraph)` For an inplace reduction of a graph to a subgraph you can remove nodes: `G.remove_nodes_from(n in G if n not in set(nbunch))` If you are going to compute subgraphs of your subgraphs you could end up with a chain of views that can be very slow once the chain has about 15 views in it. If they are all induced subgraphs, you can short-cut the chain by making them all subgraphs of the original graph. The graph class method `G.subgraph` does this when `G` is a subgraph. In contrast, this function allows you to choose to build chains or not, as you wish. The returned subgraph is a view on `G`. Examples -------- >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc >>> H = nx.induced_subgraph(G, [0, 1, 3]) >>> list(H.edges) [(0, 1)] >>> list(H.nodes) [0, 1, 3] ) filter_node)rPfilters show_nodes nbunch_iter subgraph_view)r0r5 induced_nodess r1rrms3TJJ))!--*?@M  A 99r2c[Rn[U5n[5nUHnURUSS5 M UR U5nUR 5(a9UR 5(aURU5nOJURU5nO8UR 5(aURU5nOURU5n[R"XUS9$)aMReturns a view of the subgraph induced by the specified edges. The induced subgraph contains each edge in `edges` and each node incident to any of those edges. Parameters ---------- G : NetworkX Graph edges : iterable An iterable of edges. Edges not present in `G` are ignored. Returns ------- subgraph : SubGraph View A read-only edge-induced subgraph of `G`. Changes to `G` are reflected in the view. Notes ----- To create a mutable subgraph with its own copies of nodes edges and attributes use `subgraph.copy()` or `Graph(subgraph)` If you create a subgraph of a subgraph recursively you can end up with a chain of subgraphs that becomes very slow with about 15 nested subgraph views. Luckily the edge_subgraph filter nests nicely so you can use the original graph as G in this function to avoid chains. We do not rule out chains programmatically so that odd cases like an `edge_subgraph` of a `restricted_view` can be created. Examples -------- >>> G = nx.path_graph(5) >>> H = G.edge_subgraph([(0, 1), (3, 4)]) >>> list(H.nodes) [0, 1, 3, 4] >>> list(H.edges) [(0, 1), (3, 4)] Nr?rx filter_edge) rPrysetupdaterz is_multigraphrshow_multidiedgesshow_multiedges show_diedges show_edgesr|)r0rnxfrer} induced_edgess r1rrsP **C JE EE  QrUNN5)M ==??11%8M//6M ==??,,U3MNN51M  Am TTr2cz[RnURU5nUR5(a9UR 5(aUR U5nOJUR U5nO8UR 5(aURU5nOURU5n[R"XUS9$)aReturns a view of `G` with hidden nodes and edges. The resulting subgraph filters out node `nodes` and edges `edges`. Filtered out nodes also filter out any of their edges. Parameters ---------- G : NetworkX Graph nodes : iterable An iterable of nodes. Nodes not present in `G` are ignored. edges : iterable An iterable of edges. Edges not present in `G` are ignored. Returns ------- subgraph : SubGraph View A read-only restricted view of `G` filtering out nodes and edges. Changes to `G` are reflected in the view. Notes ----- To create a mutable subgraph with its own copies of nodes edges and attributes use `subgraph.copy()` or `Graph(subgraph)` If you create a subgraph of a subgraph recursively you may end up with a chain of subgraph views. Such chains can get quite slow for lengths near 15. To avoid long chains, try to make your subgraph based on the original graph. We do not rule out chains programmatically so that odd cases like an `edge_subgraph` of a `restricted_view` can be created. Examples -------- >>> G = nx.path_graph(5) >>> H = nx.restricted_view(G, [0], [(1, 2), (3, 4)]) >>> list(H.nodes) [1, 2, 3, 4] >>> list(H.edges) [(2, 3)] r) rPry hide_nodesrrhide_multidiedgeshide_multiedges hide_diedges hide_edgesr|)r0rrrrrs r1rrsR **C&J ==??..u5J,,U3J ==??))%0J.J  A: NNr2c URSS9$)zReturns a directed view of the graph `graph`. Identical to graph.to_directed(as_view=True) Note that graph.to_directed defaults to `as_view=False` while this function always provides a view. Tas_view)rgraphs r1rrs   T  **r2c URSS9$)zReturns an undirected view of the graph `graph`. Identical to graph.to_undirected(as_view=True) Note that graph.to_undirected defaults to `as_view=False` while this function always provides a view. Tr)rrs r1rrs   t  ,,r2cUR5nURURUS95 U(a%URR UR5 U$)zReturns a copy of the graph G with all of the edges removed. Parameters ---------- G : graph A NetworkX graph with_data : bool (default=True) Propagate Graph and Nodes data to the new graph. See Also -------- empty_graph data) __class__rWrrr)r0 with_dataHs r1rr"sD AQWW)W,- qww Hr2cUb0UR5Hup4XURUU'M O8UR5H$up5URUR U5 M& [ R "U5 g![a M{f=f![a UHnXRUU'M NNf=f![a Mf=f)aQ Sets node attributes from a given value or dictionary of values. .. Warning:: The call order of arguments `values` and `name` switched between v1.x & v2.x. Parameters ---------- G : NetworkX Graph values : scalar value, dict-like What the node attribute should be set to. If `values` is not a dictionary, then it is treated as a single attribute value that is then applied to every node in `G`. This means that if you provide a mutable object, like a list, updates to that object will be reflected in the node attribute for every node. The attribute name will be `name`. If `values` is a dict or a dict of dict, it should be keyed by node to either an attribute value or a dict of attribute key/value pairs used to update the node's attributes. name : string (optional, default=None) Name of the node attribute to set if values is a scalar. Examples -------- After computing some property of the nodes of a graph, you may want to assign a node attribute to store the value of that property for each node:: >>> G = nx.path_graph(3) >>> bb = nx.betweenness_centrality(G) >>> isinstance(bb, dict) True >>> nx.set_node_attributes(G, bb, "betweenness") >>> G.nodes[1]["betweenness"] 1.0 If you provide a list as the second argument, updates to the list will be reflected in the node attribute for each node:: >>> G = nx.path_graph(3) >>> labels = [] >>> nx.set_node_attributes(G, labels, "labels") >>> labels.append("foo") >>> G.nodes[0]["labels"] ['foo'] >>> G.nodes[1]["labels"] ['foo'] >>> G.nodes[2]["labels"] ['foo'] If you provide a dictionary of dictionaries as the second argument, the outer dictionary is assumed to be keyed by node to an inner dictionary of node attributes for that node:: >>> G = nx.path_graph(3) >>> attrs = {0: {"attr1": 20, "attr2": "nothing"}, 1: {"attr2": 3}} >>> nx.set_node_attributes(G, attrs) >>> G.nodes[0]["attr1"] 20 >>> G.nodes[0]["attr2"] 'nothing' >>> G.nodes[1]["attr2"] 3 >>> G.nodes[2] {} Note that if the dictionary contains nodes that are not in `G`, the values are silently ignored:: >>> G = nx.Graph() >>> G.add_node(0) >>> nx.set_node_attributes(G, {0: "red", 1: "blue"}, name="color") >>> G.nodes[0]["color"] 'red' >>> 1 in G.nodes False N)itemsrKeyErrorrbrrP _clear_cache)r0valuesnamer9rerAs r1rr9sd  * '-yAGGAJt$'LLNDA  !!!$# OOA  *#) 4  *  sEBBB B> B BBB$B;:B;> C  C c Ub>URR5VVs0sHup4X4RX5_M snn$URR5VVs0sHup4X;dM X4U_M snn$s snnfs snnf)arGet node attributes from graph Parameters ---------- G : NetworkX Graph name : string Attribute name default: object (default=None) Default value of the node attribute if there is no value set for that node in graph. If `None` then nodes without this attribute are not included in the returned dict. Returns ------- Dictionary of attributes keyed by node. Examples -------- >>> G = nx.Graph() >>> G.add_nodes_from([1, 2, 3], color="red") >>> color = nx.get_node_attributes(G, "color") >>> color[1] 'red' >>> G.add_node(4) >>> color = nx.get_node_attributes(G, "color", default="yellow") >>> color[4] 'yellow' )rrrK)r0rdefaultr9rAs r1rrsm>45GGMMODODA55''ODD#$77==? @?41diJAwJ? @@E @sA; B. B)r5cUcUR5nUH%nURSS9HupEXA;dM XS M M' g![a M%f=f)aRemove node attributes from all nodes in the graph. Parameters ---------- G : NetworkX Graph *attr_names : List of Strings The attribute names to remove from the graph. nbunch : List of Nodes Remove the node attributes only from the nodes in this list. Examples -------- >>> G = nx.Graph() >>> G.add_nodes_from([1, 2, 3], color="blue") >>> nx.get_node_attributes(G, "color") {1: 'blue', 2: 'blue', 3: 'blue'} >>> nx.remove_node_attributes(G, "color") >>> nx.get_node_attributes(G, "color") {} NTr)rr)r0r5 attr_namesrmr9rAs r1rrsX0~GGG&DA{'  sA A Ac>Ub}UR5(a5UR5H uup4pVX`RUUUU'M" OUR5Huup4nX`RUUU'M OUR5(aBUR5H-uup4pXURUUUR U5 M/ O>UR5H*uup4nURUUR U5 M, [R"U5 g![a GMf=f![a Mf=f![a UR SS9H up4nXU'M Ncf=f![a Mf=f![a Mf=f)a Sets edge attributes from a given value or dictionary of values. .. Warning:: The call order of arguments `values` and `name` switched between v1.x & v2.x. Parameters ---------- G : NetworkX Graph values : scalar value, dict-like What the edge attribute should be set to. If `values` is not a dictionary, then it is treated as a single attribute value that is then applied to every edge in `G`. This means that if you provide a mutable object, like a list, updates to that object will be reflected in the edge attribute for each edge. The attribute name will be `name`. If `values` is a dict or a dict of dict, it should be keyed by edge tuple to either an attribute value or a dict of attribute key/value pairs used to update the edge's attributes. For multigraphs, the edge tuples must be of the form ``(u, v, key)``, where `u` and `v` are nodes and `key` is the edge key. For non-multigraphs, the keys must be tuples of the form ``(u, v)``. name : string (optional, default=None) Name of the edge attribute to set if values is a scalar. Examples -------- After computing some property of the edges of a graph, you may want to assign a edge attribute to store the value of that property for each edge:: >>> G = nx.path_graph(3) >>> bb = nx.edge_betweenness_centrality(G, normalized=False) >>> nx.set_edge_attributes(G, bb, "betweenness") >>> G.edges[1, 2]["betweenness"] 2.0 If you provide a list as the second argument, updates to the list will be reflected in the edge attribute for each edge:: >>> labels = [] >>> nx.set_edge_attributes(G, labels, "labels") >>> labels.append("foo") >>> G.edges[0, 1]["labels"] ['foo'] >>> G.edges[1, 2]["labels"] ['foo'] If you provide a dictionary of dictionaries as the second argument, the entire dictionary will be used to update edge attributes:: >>> G = nx.path_graph(3) >>> attrs = {(0, 1): {"attr1": 20, "attr2": "nothing"}, (1, 2): {"attr2": 3}} >>> nx.set_edge_attributes(G, attrs) >>> G[0][1]["attr1"] 20 >>> G[0][1]["attr2"] 'nothing' >>> G[1][2]["attr2"] 3 The attributes of one Graph can be used to set those of another. >>> H = nx.path_graph(3) >>> nx.set_edge_attributes(H, G.edges) Note that if the dict contains edges that are not in `G`, they are silently ignored:: >>> G = nx.Graph([(0, 1)]) >>> nx.set_edge_attributes(G, {(1, 2): {"weight": 2.0}}) >>> (1, 2) in G.edges() False For multigraphs, the `values` dict is expected to be keyed by 3-tuples including the edge key:: >>> MG = nx.MultiGraph() >>> edges = [(0, 1), (0, 1)] >>> MG.add_edges_from(edges) # Returns list of edge keys [0, 1] >>> attributes = {(0, 1, 0): {"cost": 21}, (0, 1, 1): {"cost": 7}} >>> nx.set_edge_attributes(MG, attributes) >>> MG[0][1][0]["cost"] 21 >>> MG[0][1][1]["cost"] 7 If MultiGraph attributes are desired for a Graph, you must convert the 3-tuple multiedge to a 2-tuple edge and the last multiedge's attribute value will overwrite the previous values. Continuing from the previous case we get:: >>> H = nx.path_graph([0, 1, 2]) >>> nx.set_edge_attributes(H, {(u, v): ed for u, v, ed in MG.edges.data()}) >>> nx.get_edge_attributes(H, "cost") {(0, 1): 7} NTr) rr_adjrrbrrrPr) r0rrurekeyvaluerrAs r1rrsJ  $  *0,,.&KQ327q ! S)$/+9 &,\\^MFQE-2q ! T*&4 ??  "(,,. sFF1IaL%,,Q/#1 $\\^ FF1IaL''*, OOA5$ $ $gg4g0 d#T 1 $   s-ED- EE(D?<E/$E=1!F- D<7E;D<<E? E  E E  E'E:9E:= F  F  FFc$UR5(aURSSS9nOURSS9nUb(UVs0sHoDSSUSRX5_M sn$UVs0sHoAUS;dM USSUSU_M sn$s snfs snf)aGet edge attributes from graph Parameters ---------- G : NetworkX Graph name : string Attribute name default: object (default=None) Default value of the edge attribute if there is no value set for that edge in graph. If `None` then edges without this attribute are not included in the returned dict. Returns ------- Dictionary of attributes keyed by edge. For (di)graphs, the keys are 2-tuples of the form: (u, v). For multi(di)graphs, the keys are 3-tuples of the form: (u, v, key). Examples -------- >>> G = nx.Graph() >>> nx.add_path(G, [1, 2, 3], color="red") >>> color = nx.get_edge_attributes(G, "color") >>> color[(1, 2)] 'red' >>> G.add_edge(3, 4) >>> color = nx.get_edge_attributes(G, "color", default="yellow") >>> color[(3, 4)] 'yellow' TkeysrrN)rrrK)r0rrrxs r1r r psB T-T":?@%Q#2" $00%@@). @A!B%- AcrFAbE$K  @@A @s!B% B 5B )ebunchcLUc4UR5(aURSS9OUR5nUHVnUR5(aURSSS9OURSS9nUHGtpV[U5U;dMXc M MX g![a M/f=f)aRemove edge attributes from all edges in the graph. Parameters ---------- G : NetworkX Graph *attr_names : List of Strings The attribute names to remove from the graph. Examples -------- >>> G = nx.path_graph(3) >>> nx.set_edge_attributes(G, {(u, v): u + v for u, v in G.edges()}, name="weight") >>> nx.get_edge_attributes(G, "weight") {(0, 1): 1, (1, 2): 3} >>> remove_edge_attributes(G, "weight") >>> nx.get_edge_attributes(G, "weight") {} NT)rrr)rrtupler)r0rrrmrrrAs r1r!r!s(~'('8'8d#aggi-.__->->AGGDG )AGGQUGDV EQQx6!  s B B#"B#cUR5(a,[URU5URU55nU$UR U5nU$)aBReturns all of the neighbors of a node in the graph. If the graph is directed returns predecessors as well as successors. Parameters ---------- graph : NetworkX graph Graph to find neighbors. node : node The node whose neighbors will be returned. Returns ------- neighbors : iterator Iterator of neighbors )rr predecessors successorsr )rnoders r1r"r"sQ$ u))$/1A1A$1GH M& Mr2czURR5URUR5- U1- $)a"Returns the non-neighbors of the node in the graph. Parameters ---------- graph : NetworkX graph Graph to find neighbors. node : node The node whose neighbors will be returned. Returns ------- non_neighbors : set Set of nodes in the graph that are not neighbors of the node. )rr)rrs r1r#r#s3 ::?? uzz$/446 6$ ??r2c## UR5(a!UHn[X5HnX4v M M g[U5nU(a6UR5nU[X5- HnX4v M U(aM5gg7f)zReturns the nonexistent edges in the graph. Parameters ---------- graph : NetworkX graph. Graph to find nonexistent edges. Returns ------- non_edges : iterator Iterator of edges that are not in the graph. N)rr#rpop)rrrers r1r$r$sr A"5,f -E  AS]*f +es A>> G = nx.complete_graph(5) >>> sorted(nx.common_neighbors(G, 0, 1)) [2, 3, 4] zu is not in the graph.zv is not in the graph.)rPrQrr)r0rres r1r%r%sb8 z788z788 66!9>> affQinn.!7 77r2r7c^Ub4UR"U6nUcSU<S3n[R"U5eTU;$[U5(ag[ U4SjUR SS955$)aReturns True if `G` has weighted edges. Parameters ---------- G : graph A NetworkX graph. edge : tuple, optional A 2-tuple specifying the only edge in `G` that will be tested. If None, then every edge in `G` is tested. weight: string, optional The attribute name used to query for edge weights. Returns ------- bool A boolean signifying if `G`, or the specified edge, is weighted. Raises ------ NetworkXError If the specified edge does not exist. Examples -------- >>> G = nx.path_graph(4) >>> nx.is_weighted(G) False >>> nx.is_weighted(G, (2, 3)) False >>> G = nx.DiGraph() >>> G.add_edge(1, 2, weight=1) >>> nx.is_weighted(G) True Edge  does not exist.Fc34># UH upnTU;v M g7frDrErFrrerr7s r1rGis_weighted..XsC0B*!v~0BsTr) get_edge_datarPrQr(allrr0edger7rmsgs ` r1r&r&&sqN % <$!12C""3' '~{{ CT0BC CCr2) edge_attrsc^UbCUR"U6nUcSU<S3n[R"U5eTU;=(a UTS:$[U4SjUR SS955$)awReturns True if `G` has negatively weighted edges. Parameters ---------- G : graph A NetworkX graph. edge : tuple, optional A 2-tuple specifying the only edge in `G` that will be tested. If None, then every edge in `G` is tested. weight: string, optional The attribute name used to query for edge weights. Returns ------- bool A boolean signifying if `G`, or the specified edge, is negatively weighted. Raises ------ NetworkXError If the specified edge does not exist. Examples -------- >>> G = nx.Graph() >>> G.add_edges_from([(1, 3), (2, 4), (2, 6)]) >>> G.add_edge(1, 2, weight=4) >>> nx.is_negatively_weighted(G, (1, 2)) False >>> G[2][4]["weight"] = -2 >>> nx.is_negatively_weighted(G) True >>> G = nx.DiGraph() >>> edges = [("0", "3", 3), ("0", "1", -5), ("1", "0", -2)] >>> G.add_weighted_edges_from(edges) >>> nx.is_negatively_weighted(G) True rrrc3R># UHupnTU;=(a UTS:v M g7f)rNrErs r1rG)is_negatively_weighted..s,XEWzqTv~2$v,"22EWs$'Tr)rrPrQanyrrs ` r1r'r'[stX % <$!12C""3' '~2$v,"22 XQWWRVWEWX XXr2cR[URR55(+$)abReturns True if `G` has no edges. Parameters ---------- G : graph A NetworkX graph. Returns ------- bool True if `G` has no edges, and False otherwise. Notes ----- An empty graph can have nodes but not edges. The empty graph with zero nodes is known as the null graph. This is an $O(n)$ operation where n is the number of nodes in the graph. )rrrr/s r1r(r(s(166==?# ##r2cDSURR55$)aReturns an iterator over nodes with self loops. A node with a self loop has an edge with both ends adjacent to that node. Returns ------- nodelist : iterator A iterator over nodes with self loops. See Also -------- selfloop_edges, number_of_selfloops Examples -------- >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc >>> G.add_edge(1, 1) >>> G.add_edge(1, 2) >>> list(nx.nodes_with_selfloops(G)) [1] c38# UHupX;dM Uv M g7frDrErFr9nbrss r1rG'nodes_with_selfloops..s 9^'!qyAA^s  )rrr/s r1r*r*s0 :QVV\\^ 99r2c ^^TSLa}UR5(aGUSLa!SURR55$SURR55$SURR55$TSLaUR5(aOUSLa%UU4SjURR55$UU4SjURR55$UU4SjURR55$UR5(aGUSLa!S URR55$S URR55$S URR55$) aVReturns an iterator over selfloop edges. A selfloop edge has the same node at both ends. Parameters ---------- G : graph A NetworkX graph. data : string or bool, optional (default=False) Return selfloop edges as two tuples (u, v) (data=False) or three-tuples (u, v, datadict) (data=True) or three-tuples (u, v, datavalue) (data='attrname') keys : bool, optional (default=False) If True, return edge keys with each edge. default : value, optional (default=None) Value used for edges that don't have the requested attribute. Only relevant if data is not True or False. Returns ------- edgeiter : iterator over edge tuples An iterator over all selfloop edges. See Also -------- nodes_with_selfloops, number_of_selfloops Examples -------- >>> G = nx.MultiGraph() # or Graph, DiGraph, MultiDiGraph, etc >>> ekey = G.add_edge(1, 1) >>> ekey = G.add_edge(1, 2) >>> list(nx.selfloop_edges(G)) [(1, 1)] >>> list(nx.selfloop_edges(G, data=True)) [(1, 1, {})] >>> list(nx.selfloop_edges(G, keys=True)) [(1, 1, 0)] >>> list(nx.selfloop_edges(G, keys=True, data=True)) [(1, 1, 0, {})] Tc3t# UH.upX;dM X!R5H up4XX44v M M0 g7frD)r)rFr9rkrAs r1rG!selfloop_edges..sB#1y!!% 1L!0!#1s 8'8c3p# UH,upX;dM X!R5H nXU4v M M. g7frD)r)rFr9rrAs r1rGrsA#1y"W^^-1I.#1s 6%6c3@# UHupX;dM XX!4v M g7frDrErs r1rGrsO>QYOQ47O>s  Fc 3># UH>upX;dM X!R5Hup4XX4RTT54v M M@ g7frD)rrK)rFr9rrrArrs r1rGrsO#1y4!% 1eeD'23!04#1s A 7A c3># UH<upX;dM X!R5HnXURTT54v M M> g7frD)rrK)rFr9rrArrs r1rGr sN#1y1"W^^-155w/0.1#1s A5Ac3b># UH$upX;dM XX!RTT54v M& g7frD)rK)rFr9rrrs r1rGrs3-GA93tw{{412-s //c3T# UHupX;dM X!H nXU4v M M g7frDrE)rFr9rrs r1rGrs:#1y"W1I%#1s ((c3v# UH/upX;dM [[X!55HnX4v M M1 g7frD)rIlen)rFr9rrMs r1rGrsA#1y#3tw<0F1#1s 9(9c3:# UHupX;dM X4v M g7frDrErs r1rGr&sF.wqAIFQF.s  )rrr)r0rrrs ` `r1r)r)sGT t| ??  t|#$66<<>#$66<<>P166<<>O O U  ??  t|#$66<<>#$66<<> vv||~  ??  t|#$66<<>#$66<<>G!&&,,.F Fr2cN[S[R"U555$)agReturns the number of selfloop edges. A selfloop edge has the same node at both ends. Returns ------- nloops : int The number of selfloops. See Also -------- nodes_with_selfloops, selfloop_edges Examples -------- >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc >>> G.add_edge(1, 1) >>> G.add_edge(1, 2) >>> nx.number_of_selfloops(G) 1 c3&# UHnSv M g7f)r>NrE)rF_s r1rG&number_of_selfloops..?s/.Qq.s)sumrPr)r/s r1r+r+)s , /"++A./ //r2c^[U4Sj[RRU555$![[ 4a gf=f)akReturns whether or not the specified path exists. For it to return True, every node on the path must exist and each consecutive pair must be connected via one or more edges. Parameters ---------- G : graph A NetworkX graph. path : list A list of nodes which defines the path to traverse Returns ------- bool True if `path` is a valid path in `G` c3L># UHupUTRU;v M g7frD)r)rFrnbrr0s r1rGis_path..Ws"P8O943!&&,&8Os!$F)rrPutilsrr TypeError)r0paths` r1r-r-Bs?(P8I8I$8OPPP i s15AAc^UR5nSn[R"X5(d[R"S5e[RR U5H[upVU(a8U[ U4SjURUUR555- nMDX@RUUT- nM] U$)aReturns total cost associated with specified path and weight Parameters ---------- G : graph A NetworkX graph. path: list A list of node labels which defines the path to traverse weight: string A string indicating which edge attribute to use for path cost Returns ------- cost: int or float An integer or a float representing the total cost with respect to the specified weight of the specified path Raises ------ NetworkXNoPath If the specified edge does not exist. rzpath does not existc3,># UH oTv M g7frDrE)rFrer7s r1rGpath_weight..|sF+Ea& +Erg) rrPr-NetworkXNoPathrrminrr)r0rr7 multigraphcostrrs ` r1r,r,\s2"J D ::a   566XX&&t,   CF166$<+<+C+C+EFF FD FF4L%f- -D - Kr2rD)NN)T)Nr7)FFN)4__doc__ collectionsr itertoolsrnetworkxrPnetworkx.utilsrr__all__rrr r r r rr rrTrrrrrrrrrrrrrrrrr r!r"r#r$r%r& _dispatchabler'r(r*r)r+r-r,rEr2r1rs<C8( V $  FO. = / d$ .FN@D.+:\8Uv5Op+- .bJ!AH37!HGT'AT37 F2@&2Z  8! 8F2DjX&2Y'2Yj$.:6cGL024#r2