networkx 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39e75c0ad21604275a008c53a29f282d681f3c50cb7648470cc6e4e2cffa5071
-  data.tar.gz: 93e93f5a2603beb715b38856518ed47e698c0978c5ff02a737a7baff68357e8c
+  metadata.gz: 4bce7e05d9da7dd9774ad976cb82c8de0bd5847be9fb0dfc07af1042568446a9
+  data.tar.gz: '085683454ca374c50f594509e13da7c3114131e54936a11f6daf4dd3f4924b29'
 SHA512:
-  metadata.gz: 1ce185b8e9246db7b791d4d1800b39d1ad9a5f1036c99899842554c31e2400469d775acd382c2dfc27275857db58e66228062502bffefb16ddca4c3a63b346fe
-  data.tar.gz: 9b615db49ec2ba5e06bbfecf1710849d079661b301a85493740434eae464bfd74c250c38c31ed2cc5dfb93983cb2c7315fe27452c2f6a243051ac1f80512816b
+  metadata.gz: 91cdd246c4692b87a90405676f58a330257ecc02d6cdc9e55c79428afc4d22a9d621fd175d6408e0a7f6aafec50deaa8cd2eb9a0d5ef49360befd5ae8e88dd30
+  data.tar.gz: 79bade11b9709a78102bb83d13d77a3abe661fbaf75bdc18dbc5f822e71d6c5ecd53c8b7c46324cf9d6eda1df570f299c77191e8079426c50e4fd5b3f87e7ffd

data/lib/networkx/auxillary_functions/cliques.rb

@@ -5,15 +5,15 @@ module NetworkX
   #
   # @return [Array<Array<Object>>] Arrays of nodes in the cliques
   def self.find_cliques(graph)
-    return nil if graph.nodes.empty?
+    return nil if graph.nodes(data: true).empty?
 
     q = [nil]
     adj = {}
-    graph.nodes.each_key { |u| adj[u] = [] }
+    graph.nodes(data: true).each_key { |u| adj[u] = [] }
     graph.adj.each { |u, u_edges| u_edges.each_key { |v| adj[u] << v if u != v } }
 
-    subg = graph.nodes.keys
-    cand = graph.nodes.keys
+    subg = graph.nodes(data: true).keys
+    cand = graph.nodes(data: true).keys
     u = subg.max { |n1, n2| (cand & adj[n1]).length <=> (cand & adj[n2]).length }
     ext_u = cand - adj[u]
     stack = []

data/lib/networkx/auxillary_functions/cycles.rb

@@ -6,7 +6,7 @@ module NetworkX
   #
   # @return [Array<Array<Object>>] Arrays of nodes in the cycles
   def self.cycle_basis(graph, root = nil)
-    gnodes = graph.nodes.keys
+    gnodes = graph.nodes(data: true).keys
     cycles = []
     until gnodes.empty?
       root = gnodes.shift if root.nil?

data/lib/networkx/auxillary_functions/dag.rb

@@ -34,14 +34,14 @@ module NetworkX
     raise ArgumentError, 'Topological Sort not defined on undirected graphs!' unless graph.directed?
 
     nodes = []
-    indegree_map = graph.nodes.each_key.map do |u|
+    indegree_map = graph.nodes(data: true).each_key.map do |u|
       [u, graph.in_degree(u)] if graph.in_degree(u).positive?
     end.compact.to_h
-    zero_indegree = graph.nodes.each_key.select { |u| graph.in_degree(u).zero? }
+    zero_indegree = graph.nodes(data: true).each_key.select { |u| graph.in_degree(u).zero? }
 
     until zero_indegree.empty?
       node = zero_indegree.shift
-      raise ArgumentError, 'Graph changed during iteration!' unless graph.nodes.has_key?(node)
+      raise ArgumentError, 'Graph changed during iteration!' unless graph.nodes(data: true).has_key?(node)
 
       graph.adj[node].each_key do |child|
         indegree_map[child] -= 1

data/lib/networkx/auxillary_functions/eccentricity.rb

@@ -7,10 +7,10 @@ module NetworkX
   # @return [Array<Numeric>, Numeric] eccentricity/eccentricites of all nodes
   def self.eccentricity(graph, node = nil)
     e = {}
-    graph.nodes.each do |u, _|
+    graph.nodes(data: true).each do |u, _|
       length = single_source_shortest_path_length(graph, u)
       l = length.length
-      raise ArgumentError, 'Found infinite path length!' unless l == graph.nodes.length
+      raise ArgumentError, 'Found infinite path length!' unless l == graph.nodes(data: true).length
 
       e[u] = length.max_by { |a| a[1] }[1]
     end

data/lib/networkx/auxillary_functions/mis.rb

@@ -6,13 +6,15 @@ module NetworkX
   #
   # @return [Numeric] radius of the graph
   def self.maximal_independent_set(graph, nodes)
-    raise 'The array containing the nodes should be a subset of the graph!' if (graph.nodes.keys - nodes).empty?
+    if (graph.nodes(data: true).keys - nodes).empty?
+      raise 'The array containing the nodes should be a subset of the graph!'
+    end
 
     neighbours = []
     nodes.each { |u| graph.adj[u].each { |v, _| neighbours |= [v] } }
     raise 'Nodes is not an independent set of graph!' if (neighbours - nodes).empty?
 
-    available_nodes = graph.nodes.keys - (neighbours | nodes)
+    available_nodes = graph.nodes(data: true).keys - (neighbours | nodes)
     until available_nodes.empty?
       node = available_nodes.sample
       nodes << node

data/lib/networkx/auxillary_functions/mst.rb

@@ -20,8 +20,8 @@ module NetworkX
     mst = Marshal.load(Marshal.dump(graph))
     mst.clear
     edges = get_edges_weights(graph).sort_by { |a| a[1] }
-    union_find = UnionFind.new(graph.nodes.keys)
-    while edges.any? && mst.nodes.length <= graph.nodes.length
+    union_find = UnionFind.new(graph.nodes(data: true).keys)
+    while edges.any? && mst.nodes(data: true).length <= graph.nodes(data: true).length
       edge = edges.shift
       unless union_find.connected?(edge[0][0], edge[0][1])
         union_find.union(edge[0][0], edge[0][1])

data/lib/networkx/auxillary_functions/vitality.rb

@@ -7,7 +7,7 @@ module NetworkX
   # @return [Numeric] closeness vitality of the given node
   def self.closeness_vitality(graph, node)
     before = wiener_index(graph)
-    after = wiener_index(graph.subgraph(graph.nodes.keys - [node]))
+    after = wiener_index(graph.subgraph(graph.nodes(data: true).keys - [node]))
     before - after
   end
 end

data/lib/networkx/converters/to_csv.rb

@@ -10,7 +10,7 @@ module NetworkX
       csv << graph.graph.keys
       csv << graph.graph.values
       csv << ['graph_nodes']
-      graph.nodes.each do |u, attrs|
+      graph.nodes(data: true).each do |u, attrs|
         node_attrs = [u]
         attrs.each do |k, v|
           node_attrs << k

data/lib/networkx/flow/capacityscaling.rb

@@ -11,7 +11,7 @@ module NetworkX
   # @return [Boolean] whether there exists a negative cycle in graph
   def self.negative_edge_cycle(graph)
     newnode = generate_unique_node
-    graph.add_edges(graph.nodes.keys.map { |n| [newnode, n] })
+    graph.add_edges(graph.nodes(data: true).keys.map { |n| [newnode, n] })
     begin
       bellmanford_predecesor_distance(graph, newnode)
     rescue ArgumentError
@@ -25,10 +25,10 @@ module NetworkX
   # Detects the unboundedness in the residual graph
   def self._detect_unboundedness(residual)
     g = NetworkX::DiGraph.new
-    g.add_nodes(residual.nodes.keys.zip(residual.nodes.values))
+    g.add_nodes(residual.nodes(data: true).keys.zip(residual.nodes(data: true).values))
     inf = residual.graph[:inf]
 
-    residual.nodes.each do |u, _attr|
+    residual.nodes(data: true).each do |u, _attr|
       residual.adj[u].each do |v, uv_attrs|
         w = inf
         uv_attrs.each { |_key, edge_attrs| w = [w, edge_attrs[:weight]].min if edge_attrs[:capacity] == inf }
@@ -41,10 +41,10 @@ module NetworkX
   # Returns the residual graph of the given graph
   def self._build_residual_network(graph)
     raise ArgumentError, 'Sum of demands should be 0!' unless \
-                         graph.nodes.values.map { |attr| attr[:demand] || 0 }.inject(0, :+).zero?
+                         graph.nodes(data: true).values.map { |attr| attr[:demand] || 0 }.inject(0, :+).zero?
 
     residual = NetworkX::MultiDiGraph.new(inf: 0)
-    residual.add_nodes(graph.nodes.map { |u, attr| [u, {excess: (attr[:demand] || 0) * -1, potential: 0}] })
+    residual.add_nodes(graph.nodes(data: true).map { |u, attr| [u, {excess: (attr[:demand] || 0) * -1, potential: 0}] })
     inf = Float::INFINITY
     edge_list = []
 
@@ -66,9 +66,11 @@ module NetworkX
       end
     end
 
-    temp_inf = [residual.nodes.map { |_u, attrs| attrs[:excess].abs }.inject(0, :+), edge_list.map do |_, _, _, e|
-      (e.has_key?(:capacity) && e[:capacity] != inf ? e[:capacity] : 0)
-    end.inject(0, :+) * 2].max
+    temp_inf = [residual.nodes(data: true).map do |_u, attrs|
+                  attrs[:excess].abs
+                end.inject(0, :+), edge_list.map do |_, _, _, e|
+                                     (e.has_key?(:capacity) && e[:capacity] != inf ? e[:capacity] : 0)
+                                   end.inject(0, :+) * 2].max
     inf = temp_inf.zero? ? 1 : temp_inf
 
     edge_list.each do |u, v, k, e|
@@ -88,7 +90,7 @@ module NetworkX
     inf = Float::INFINITY
 
     if graph.multigraph?
-      graph.nodes.each_key do |u|
+      graph.nodes(data: true).each_key do |u|
         flow_dict[u] = {}
         graph.adj[u].each do |v, uv_edges|
           flow_dict[u][v] = uv_edges.transform_values do |e|
@@ -102,7 +104,7 @@ module NetworkX
         end
       end
     else
-      graph.nodes.each_key do |u|
+      graph.nodes(data: true).each_key do |u|
         flow_dict[u] = graph.adj[u].to_h do |v, e|
           [v, u != v || (e[:capacity] || inf) <= 0 || (e[:weight] || 0) >= 0 ? 0 : e[:capacity]]
         end
@@ -163,7 +165,7 @@ module NetworkX
       s_set = Set.new
       t_set = Set.new
 
-      residual.nodes.each do |u, _attrs|
+      residual.nodes(data: true).each do |u, _attrs|
         excess = r_nodes[u][:excess]
         if excess >= delta
           s_set.add(u)
@@ -236,7 +238,7 @@ module NetworkX
 
     r_nodes.each_value { |attrs| raise ArgumentError, 'No flow satisfying all demands!' if attrs[:excess] != 0 }
 
-    residual.nodes.each_key do |node|
+    residual.nodes(data: true).each_key do |node|
       residual.adj[node].each_value do |uv_edges|
         uv_edges.each_value do |k_attrs|
           flow = k_attrs[:flow]

data/lib/networkx/flow/edmondskarp.rb

@@ -84,8 +84,8 @@ module NetworkX
 
   # Helper function for the edmondskarp function
   def self.edmondskarp_impl(graph, source, target, residual, cutoff)
-    raise ArgumentError, 'Source not in graph!' unless graph.nodes.has_key?(source)
-    raise ArgumentError, 'Target not in graph!' unless graph.nodes.has_key?(target)
+    raise ArgumentError, 'Source not in graph!' unless graph.nodes(data: true).has_key?(source)
+    raise ArgumentError, 'Target not in graph!' unless graph.nodes(data: true).has_key?(target)
     raise ArgumentError, 'Source and target are same node!' if source == target
 
     res_graph = residual.nil? ? build_residual_network(graph) : residual.clone

data/lib/networkx/flow/preflowpush.rb

@@ -12,8 +12,8 @@ module NetworkX
 
   # Helper function to apply the preflow push algorithm
   def self.preflowpush_impl(graph, source, target, residual, globalrelabel_freq, value_only)
-    raise ArgumentError, 'Source not in graph!' unless graph.nodes.has_key?(source)
-    raise ArgumentError, 'Target not in graph!' unless graph.nodes.has_key?(target)
+    raise ArgumentError, 'Source not in graph!' unless graph.nodes(data: true).has_key?(source)
+    raise ArgumentError, 'Target not in graph!' unless graph.nodes(data: true).has_key?(target)
     raise ArgumentError, 'Source and Target are same!' if source == target
 
     globalrelabel_freq = 0 if globalrelabel_freq.nil?
@@ -38,7 +38,7 @@ module NetworkX
       return r_network
     end
 
-    n = r_network.nodes.length
+    n = r_network.nodes(data: true).length
     max_height = heights.map { |u, h| u == source ? -1 : h }.max
     heights[source] = n
 

data/lib/networkx/flow/shortestaugmentingpath.rb

@@ -1,8 +1,8 @@
 module NetworkX
   # Helper function for running the shortest augmenting path algorithm
   def self.shortest_augmenting_path_impl(graph, source, target, residual, two_phase, cutoff)
-    raise ArgumentError, 'Source is not in the graph!' unless graph.nodes.has_key?(source)
-    raise ArgumentError, 'Target is not in the graph!' unless graph.nodes.has_key?(target)
+    raise ArgumentError, 'Source is not in the graph!' unless graph.nodes(data: true).has_key?(source)
+    raise ArgumentError, 'Target is not in the graph!' unless graph.nodes(data: true).has_key?(target)
     raise ArgumentError, 'Source and Target are the same!' if source == target
 
     residual = residual.nil? ? build_residual_network(graph) : residual
@@ -35,7 +35,7 @@ module NetworkX
       return residual
     end
 
-    n = graph.nodes.length
+    n = graph.nodes(data: true).length
     m = residual.size / 2
 
     r_nodes.each do |node, attrs|

data/lib/networkx/flow/utils.rb

@@ -62,7 +62,7 @@ module NetworkX
     raise NotImplementedError, 'MultiGraph and MultiDiGraph not supported!' if graph.multigraph?
 
     r_network = NetworkX::DiGraph.new(inf: 0, flow_value: 0)
-    r_network.add_nodes(graph.nodes.keys)
+    r_network.add_nodes(graph.nodes(data: true).keys)
     inf = Float::INFINITY
     edge_list = []
 

data/lib/networkx/graph.rb

@@ -213,14 +213,13 @@ module NetworkX
       end
     end
 
-    # [TODO] Current default of `data` is true.
-    # [Alert] Change the default in the futher. Please specify the `data`.
+    # Return nodes of graph
     #
     # @param data [bool] true if you want data of each edge
     #
     # @return [Hash | Array] if data is true, it returns hash including data.
     #                        otherwise, simple nodes array.
-    def nodes(data: true)
+    def nodes(data: false)
       if data
         @nodes
       else

data/lib/networkx/link_analysis/hits.rb

@@ -8,7 +8,7 @@ module NetworkX
   #
   # @return [Array<Numeric, Numeric>] hits and authority scores
   def self.hits(graph, max_iter = 100, tol = 1e-8, nstart)
-    return [{}, {}] if graph.nodes.empty?
+    return [{}, {}] if graph.nodes(data: true).empty?
 
     h = nstart
     sum = h.values.sum

data/lib/networkx/operators/binary.rb

@@ -27,12 +27,12 @@ module NetworkX
   def self.convert_to_distinct_labels(graph, starting_int = -1)
     new_graph = graph.class.new
 
-    idx_dict = graph.nodes.keys.to_h do |v|
+    idx_dict = graph.nodes(data: true).keys.to_h do |v|
       starting_int += 1
       [v, starting_int]
     end
 
-    graph.nodes.each do |u, attrs|
+    graph.nodes(data: true).each do |u, attrs|
       new_graph.add_node(u.to_s + idx_dict[u].to_s, **attrs)
     end
 
@@ -60,9 +60,12 @@ module NetworkX
     result = g1.class.new
 
     raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
-    raise ArgumentError, 'Node sets must be equal!' unless (g1.nodes.keys - g2.nodes.keys).empty?
 
-    g1.nodes.each { |u, attrs| result.add_node(u, **attrs) }
+    unless (g1.nodes(data: true).keys - g2.nodes(data: true).keys).empty?
+      raise ArgumentError, 'Node sets must be equal!'
+    end
+
+    g1.nodes(data: true).each { |u, attrs| result.add_node(u, **attrs) }
 
     g1, g2 = g2, g1 if g1.number_of_edges > g2.number_of_edges
     g1.adj.each do |u, u_edges|
@@ -91,9 +94,12 @@ module NetworkX
     result = g1.class.new
 
     raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
-    raise ArgumentError, 'Node sets must be equal!' unless (g1.nodes.keys - g2.nodes.keys).empty?
 
-    g1.nodes.each { |u, attrs| result.add_node(u, **attrs) }
+    unless (g1.nodes(data: true).keys - g2.nodes(data: true).keys).empty?
+      raise ArgumentError, 'Node sets must be equal!'
+    end
+
+    g1.nodes(data: true).each { |u, attrs| result.add_node(u, **attrs) }
 
     g1.adj.each do |u, u_edges|
       u_edges.each do |v, uv_attrs|
@@ -121,9 +127,12 @@ module NetworkX
     result = g1.class.new
 
     raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
-    raise ArgumentError, 'Node sets must be equal!' unless (g1.nodes.keys - g2.nodes.keys).empty?
 
-    g1.nodes.each { |u, attrs| result.add_node(u, **attrs) }
+    unless (g1.nodes(data: true).keys - g2.nodes(data: true).keys).empty?
+      raise ArgumentError, 'Node sets must be equal!'
+    end
+
+    g1.nodes(data: true).each { |u, attrs| result.add_node(u, **attrs) }
 
     g1.adj.each do |u, u_edges|
       u_edges.each do |v, uv_attrs|
@@ -166,8 +175,8 @@ module NetworkX
 
     raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
 
-    result.add_nodes(g1.nodes.map { |u, attrs| [u, attrs] })
-    result.add_nodes(g2.nodes.map { |u, attrs| [u, attrs] })
+    result.add_nodes(g1.nodes(data: true).map { |u, attrs| [u, attrs] })
+    result.add_nodes(g2.nodes(data: true).map { |u, attrs| [u, attrs] })
 
     if g1.multigraph?
       g1.adj.each { |u, e| e.each { |v, uv_edges| uv_edges.each_value { |attrs| result.add_edge(u, v, **attrs) } } }
@@ -192,14 +201,16 @@ module NetworkX
     new_graph.graph.merge!(g1.graph)
     new_graph.graph.merge!(g2.graph)
 
-    raise ArgumentError, 'Graphs must be disjoint!' unless (g1.nodes.keys & g2.nodes.keys).empty?
+    unless (g1.nodes(data: true).keys & g2.nodes(data: true).keys).empty?
+      raise ArgumentError, 'Graphs must be disjoint!'
+    end
 
     g1_edges = get_edges(g1)
     g2_edges = get_edges(g2)
 
-    new_graph.add_nodes(g1.nodes.keys)
+    new_graph.add_nodes(g1.nodes(data: true).keys)
     new_graph.add_edges(g1_edges)
-    new_graph.add_nodes(g2.nodes.keys)
+    new_graph.add_nodes(g2.nodes(data: true).keys)
     new_graph.add_edges(g2_edges)
 
     new_graph

data/lib/networkx/operators/product.rb

@@ -28,8 +28,8 @@ module NetworkX
   # Returns the node product of nodes of two graphs
   def self.node_product(g1, g2)
     n_product = []
-    g1.nodes.each do |k1, attrs1|
-      g2.nodes.each do |k2, attrs2|
+    g1.nodes(data: true).each do |k1, attrs1|
+      g2.nodes(data: true).each do |k2, attrs2|
         n_product << [[k1, k2], hash_product(attrs1, attrs2)]
       end
     end
@@ -62,7 +62,7 @@ module NetworkX
   def self.edges_cross_nodes(g1, g2)
     result = []
     edges_in_array(g1).each do |u, v, d|
-      g2.nodes.each_key do |x|
+      g2.nodes(data: true).each_key do |x|
         result << [[u, x], [v, x], d]
       end
     end
@@ -72,7 +72,7 @@ module NetworkX
   # Returns the product of directed nodes with edges
   def self.nodes_cross_edges(g1, g2)
     result = []
-    g1.nodes.each_key do |x|
+    g1.nodes(data: true).each_key do |x|
       edges_in_array(g2).each do |u, v, d|
         result << [[x, u], [x, v], d]
       end
@@ -84,8 +84,8 @@ module NetworkX
   def self.edges_cross_nodes_and_nodes(g1, g2)
     result = []
     edges_in_array(g1).each do |u, v, d|
-      g2.nodes.each_key do |x|
-        g2.nodes.each_key do |y|
+      g2.nodes(data: true).each_key do |x|
+        g2.nodes(data: true).each_key do |y|
           result << [[u, x], [v, y], d]
         end
       end
@@ -174,8 +174,8 @@ module NetworkX
     raise ArgumentError, 'Power must be a positive quantity!' if pow <= 0
 
     result = NetworkX::Graph.new
-    result.add_nodes(graph.nodes.map { |n, attrs| [n, attrs] })
-    graph.nodes.each do |n, _attrs|
+    result.add_nodes(graph.nodes(data: true).map { |n, attrs| [n, attrs] })
+    graph.nodes(data: true).each do |n, _attrs|
       seen = {}
       level = 1
       next_level = graph.adj[n]

data/lib/networkx/operators/unary.rb

@@ -8,9 +8,9 @@ module NetworkX
     result = Marshal.load(Marshal.dump(graph))
     result.clear
 
-    result.add_nodes(graph.nodes.map { |u, attrs| [u, attrs] })
+    result.add_nodes(graph.nodes(data: true).map { |u, attrs| [u, attrs] })
     graph.adj.each do |u, u_edges|
-      graph.nodes.each { |v, attrs| result.add_edge(u, v, **attrs) if !u_edges.has_key?(v) && u != v }
+      graph.nodes(data: true).each { |v, attrs| result.add_edge(u, v, **attrs) if !u_edges.has_key?(v) && u != v }
     end
     result
   end

data/lib/networkx/shortest_path/dense.rb

@@ -7,7 +7,7 @@ module NetworkX
   #                                                     b/w all pairs of nodes
   def self.floyd_warshall(graph)
     a, index = to_matrix(graph, Float::INFINITY, 'min')
-    nodelen = graph.nodes.length
+    nodelen = graph.nodes(data: true).length
     (0..(nodelen - 1)).each { |i| a[i, i] = 0 }
     (0..(nodelen - 1)).each do |k|
       (0..(nodelen - 1)).each do |i|

data/lib/networkx/shortest_path/unweighted.rb

@@ -34,7 +34,7 @@ module NetworkX
 
     cutoff = Float::INFINITY if cutoff.nil?
     nextlevel = {source => 1}
-    help_single_shortest_path_length(graph.adj, nextlevel, cutoff).take(graph.nodes.length)
+    help_single_shortest_path_length(graph.adj, nextlevel, cutoff).take(graph.nodes(data: true).length)
   end
 
   # Computes shortest path values to all nodes from all nodes
@@ -45,7 +45,7 @@ module NetworkX
   # @return [Array<Object, Array<Object, Numeric>>] path lengths for all nodes from all nodes
   def self.all_pairs_shortest_path_length(graph, cutoff = nil)
     shortest_paths = []
-    graph.nodes.each_key { |n| shortest_paths << [n, single_source_shortest_path_length(graph, n, cutoff)] }
+    graph.nodes(data: true).each_key { |n| shortest_paths << [n, single_source_shortest_path_length(graph, n, cutoff)] }
     shortest_paths
   end
 
@@ -93,7 +93,7 @@ module NetworkX
   # @return [Array<Object, Hash {Object => Array<Object> }>] paths for all nodes from all nodes
   def self.all_pairs_shortest_path(graph, cutoff = nil)
     shortest_paths = []
-    graph.nodes.each_key { |n| shortest_paths << [n, single_source_shortest_path(graph, n, cutoff)] }
+    graph.nodes(data: true).each_key { |n| shortest_paths << [n, single_source_shortest_path(graph, n, cutoff)] }
     shortest_paths
   end
 

data/lib/networkx/shortest_path/weighted.rb

@@ -188,7 +188,7 @@ module NetworkX
   #          paths and path lengths between all nodes
   def self.all_pairs_dijkstra(graph, cutoff = nil)
     path = []
-    graph.nodes.each_key { |n| path << [n, singlesource_dijkstra(graph, n, nil, cutoff)] }
+    graph.nodes(data: true).each_key { |n| path << [n, singlesource_dijkstra(graph, n, nil, cutoff)] }
     path
   end
 
@@ -200,7 +200,7 @@ module NetworkX
   # @return [Array<Object, Hash{ Object => Numeric }>] path lengths between all nodes
   def self.all_pairs_dijkstra_path_length(graph, cutoff = nil)
     path_lengths = []
-    graph.nodes.each_key { |n| path_lengths << [n, singlesource_dijkstra_path_length(graph, n, cutoff)] }
+    graph.nodes(data: true).each_key { |n| path_lengths << [n, singlesource_dijkstra_path_length(graph, n, cutoff)] }
     path_lengths
   end
 
@@ -212,7 +212,7 @@ module NetworkX
   # @return [Array<Object, Hash{ Object => Array<Object> }>] path lengths between all nodes
   def self.all_pairs_dijkstra_path(graph, cutoff = nil)
     paths = []
-    graph.nodes.each_key { |n| paths << singlesource_dijkstra_path(graph, n, cutoff) }
+    graph.nodes(data: true).each_key { |n| paths << singlesource_dijkstra_path(graph, n, cutoff) }
     paths
   end
 
@@ -221,7 +221,7 @@ module NetworkX
     pred = sources.product([[]]).to_h if pred.nil?
     dist = sources.product([0]).to_h if dist.nil?
 
-    inf, n, count, q, in_q = Float::INFINITY, graph.nodes.length, {}, sources.clone, Set.new(sources)
+    inf, n, count, q, in_q = Float::INFINITY, graph.nodes(data: true).length, {}, sources.clone, Set.new(sources)
     until q.empty?
       u = q.shift
       in_q.delete(u)
@@ -281,7 +281,7 @@ module NetworkX
     # TODO: Detection of selfloop edges
     dist = {source => 0}
     pred = {source => []}
-    return [pred, dist] if graph.nodes.length == 1
+    return [pred, dist] if graph.nodes(data: true).length == 1
 
     dist = help_bellman_ford(graph, [source], weight, pred, nil, dist, cutoff, target)
     [pred, dist]
@@ -360,7 +360,7 @@ module NetworkX
   # @return [Array<Object, Hash{ Object => Numeric }>] path lengths from source to all nodes
   def self.allpairs_bellmanford_path_length(graph, cutoff = nil)
     path_lengths = []
-    graph.nodes.each_key { |n| path_lengths << [n, singlesource_bellmanford_path_length(graph, n, cutoff)] }
+    graph.nodes(data: true).each_key { |n| path_lengths << [n, singlesource_bellmanford_path_length(graph, n, cutoff)] }
     path_lengths
   end
 
@@ -372,13 +372,13 @@ module NetworkX
   # @return [Array<Object, Hash{ Object => Array<Object> }>] path lengths from source to all nodes
   def self.allpairs_bellmanford_path(graph, cutoff = nil)
     paths = []
-    graph.nodes.each_key { |n| paths << [n, singlesource_bellmanford_path(graph, n, cutoff)] }
+    graph.nodes(data: true).each_key { |n| paths << [n, singlesource_bellmanford_path(graph, n, cutoff)] }
     paths
   end
 
   # Helper function to get sources
   def self.get_sources(graph)
-    graph.nodes.collect { |k, _v| k }
+    graph.nodes(data: true).collect { |k, _v| k }
   end
 
   # Helper function to get distances
@@ -393,7 +393,7 @@ module NetworkX
   # Helper function to set path lengths for Johnson algorithm
   def self.set_path_lengths_johnson(graph, dist_path, new_weight)
     path_lengths = []
-    graph.nodes.each_key { |n| path_lengths << [n, dist_path.call(graph, n, new_weight)] }
+    graph.nodes(data: true).each_key { |n| path_lengths << [n, dist_path.call(graph, n, new_weight)] }
     path_lengths
   end
 
@@ -405,7 +405,7 @@ module NetworkX
   def self.johnson(graph)
     dist, pred = {}, {}
     sources = get_sources(graph)
-    graph.nodes.each_key do |n|
+    graph.nodes(data: true).each_key do |n|
       dist[n], pred[n] = 0, []
     end
     weight = get_weight(graph)

data/lib/networkx/to_matrix.rb

@@ -2,14 +2,14 @@ module NetworkX
   def self.to_matrix(graph, val, multigraph_weight = 'sum')
     is_undirected = !graph.directed?
     is_multigraph = graph.multigraph?
-    nodelen = graph.nodes.length
+    nodelen = graph.nodes(data: true).length
 
     m = Matrix.build(nodelen) { val }
     index = {}
     inv_index = {}
     ind = 0
 
-    graph.nodes.each do |u, _|
+    graph.nodes(data: true).each do |u, _|
       index[u] = ind
       inv_index[ind] = u
       ind += 1

data/lib/networkx/traversals/dfs.rb

@@ -11,7 +11,7 @@ module NetworkX
     raise KeyError, "There exists no node names #{source} in the given graph." unless graph.node?(source)
 
     depth_limit += 1 if depth_limit
-    depth_limit = graph.nodes.length if depth_limit.nil?
+    depth_limit = graph.nodes(data: true).length if depth_limit.nil?
     dfs_edges = []
     visited = [source]
     stack = [[-1, source, depth_limit, graph.neighbours(source)]]

data/lib/networkx/version.rb

@@ -1,3 +1,3 @@
 module NetworkX
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: networkx
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Athitya Kumar