networkx 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e86cfdb083751f6aa9d45d894dd4a83ec75623acd237c6cdc8e7cd356306409
-  data.tar.gz: 60ef78a9da3df8d7f61e297af48873795b21d9675138e953dd160597d9bfdc09
+  metadata.gz: 4bce7e05d9da7dd9774ad976cb82c8de0bd5847be9fb0dfc07af1042568446a9
+  data.tar.gz: '085683454ca374c50f594509e13da7c3114131e54936a11f6daf4dd3f4924b29'
 SHA512:
-  metadata.gz: a7d64db11e72ecd05bba646d89116da859caa2e48b9063b158780e625c7fdf802cd840c3aace32a00314762805a27fa1373b36795462d7640f4ed7385466d403
-  data.tar.gz: 46886910fc5f3bb550fb089af740bb5c0e32cd5a1ff3dd2394a13256ddc3f6b4e9f32c48c37d2d827b2bc8edba36cd0894201aec833a2fb4d59318f7fb85b7ae
+  metadata.gz: 91cdd246c4692b87a90405676f58a330257ecc02d6cdc9e55c79428afc4d22a9d621fd175d6408e0a7f6aafec50deaa8cd2eb9a0d5ef49360befd5ae8e88dd30
+  data.tar.gz: 79bade11b9709a78102bb83d13d77a3abe661fbaf75bdc18dbc5f822e71d6c5ecd53c8b7c46324cf9d6eda1df570f299c77191e8079426c50e4fd5b3f87e7ffd

data/.rubocop.yml

@@ -1,12 +1,12 @@
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 2.7
   Include:
     - 'lib/**/*'
     - 'spec/**/*_spec.rb'
     - 'Gemfile'
     - 'Rakefile'
-    - '*.gemspace'
+    - '*.gemspec'
   DisplayCopNames: true
 
 require:

data/README.md

@@ -1,23 +1,37 @@
 # NetworkX.rb
 
+[![Gem Version](https://badge.fury.io/rb/networkx.svg)](https://badge.fury.io/rb/networkx)
+
 [NetworkX](https://networkx.github.io/) is a very popular Python library, that handles various use-cases of the Graph Data Structure.  
 This project intends to provide a working alternative to the Ruby community, by closely mimicing as many features as possible. 
 
 ## List of contents
 
 - [Installing](#installing)
+- [Usage](#Usage)
 - [Document](#document)
-- [Roadmap](#roadmap)
 - [Contributing](#contributing)
 - [License](#license)
 
 ## Installing
 
-- Clone the repository or fork
-  - Clone this repository with `git clone https://github.com/SciRuby/networkx.rb.git`
-  - or You can fork and do clone it.
-- Navigate to networkx with `cd networkx.rb`
-- Install dependencies with `gem install bundler && bundle install`
+- install it yourself as:
+```console
+$ gem install networkx
+```
+
+
+- Or use Bundler & Gemfile
+  1. add this line to your application's Gemfile:
+  ```ruby
+  gem 'networkx'
+  ```
+  2. And then execute:
+  ```console
+  $ bundle install
+  ```
+
+## Usage
 
 ```ruby
 require 'networkx'
@@ -30,22 +44,6 @@ g.add_edge('start', 'stop')
 
 You can read [Document](https://SciRuby.github.io/networkx.rb/) for this library.
 
-## Roadmap
-
-Quite easily, any networkx user would be able to understand the number of details that have been implemented in the Python library. As a humble start towards the release of v0.1.0, the following could be the goals to achieve :
-
-- `Node` : This class should be capable of handling different types of nodes (not just `String` / `Integer`).  
-   A possible complex use-case could be XML nodes.
-
-- `Edge` : This class should be capable of handling different types of edges.  
-  Though a basic undirected Graph doesn't store any metadata in the edges, weighted edges and parametric edges are something that need to be handled.
-
-- `Graph` : The simplest of graphs.  
-  This class handles just connections between different `Node`s via `Edge`s.
-
-- `DirectedGraph` : Inherits from `Graph` class.  
-  Uses directions between `Edge`s.
-
 ## Contributing
 
 Your contributions are always welcome!  

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/link_analysis/pagerank.rb

@@ -2,61 +2,16 @@ module NetworkX
   # Computes pagerank values for the graph
   #
   # @param graph [Graph] a graph
-  # @param init [Array<Numeric>] initial pagerank values for the nodes
   # @param alpha [Numeric] the alpha value to compute the pagerank
   # @param eps [Numeric] tolerence to check for convergence
   # @param max_iter [Integer] max iterations for the pagerank algorithm to run
   #
-  # @return [Array<Numeric>] pagerank values of the graph
-  def self.pagerank(graph, init = nil, alpha = 0.85, eps = 1e-4, max_iter = 100)
-    dim = graph.nodes.length
-    if init.nil?
-      init = graph.nodes(data: false).to_h{ |i| [i, 1.0 / dim] }
-    else
-      s = init.values.sum.to_f
-      init = init.transform_values { |v| v / s }
-    end
-    raise ArgumentError, 'Init array needs to have same length as number of graph nodes!' \
-                          unless dim == init.length
-
-    matrix = []
-    elem_ind = {}
-    p = []
-    curr = init.values
-    init.keys.each_with_index { |n, i| elem_ind[n] = i }
-    graph.adj.each do |_u, u_edges|
-      adj_arr = Array.new(dim, 0)
-      u_edges.each do |v, _|
-        adj_arr[elem_ind[v]] = 1
-      end
-      matrix << adj_arr
-    end
-    (0..(dim - 1)).each do |i|
-      p[i] = []
-      (0..(dim - 1)).each { |j| p[i][j] = matrix[i][j] / (matrix[i].sum * 1.0) }
-    end
-
-    max_iter.times do |_|
-      prev = curr.clone
-      dim.times do |i|
-        ip = 0
-        dim.times { |j| ip += p.transpose[i][j] * prev[j] }
-        curr[i] = (alpha * ip) + ((1 - alpha) / (dim * 1.0))
-      end
-      err = 0
-      dim.times { |i| err += (prev[i] - curr[i]).abs }
-      return curr if err < eps
-    end
-    raise ArgumentError, 'PageRank failed to converge!'
-  end
-
-  def self.pagerank2(graph, alpha: 0.85, personalization: nil, eps: 1e-6, max_iter: 100)
+  # @return [Hash of Object => Float] pagerank values of the graph
+  def self.pagerank(graph, alpha: 0.85, personalization: nil, eps: 1e-6, max_iter: 100)
     n = graph.number_of_nodes
 
     matrix, index_to_node = NetworkX.to_matrix(graph, 0)
 
-    # index_to_node = {0=>0, 1=>1, 2=>2, 3=>3}
-
     index_from_node = index_to_node.invert
 
     probabilities = Array.new(n) do |i|
@@ -84,6 +39,7 @@ module NetworkX
       err = (0...n).map{|i| (prev[i] - curr[i]).abs }.sum
       return (0...n).map{|i| [index_to_node[i], curr[i]] }.sort.to_h if err < eps
     end
+    warn "pagerank() failed within #{max_iter} iterations. Please inclease max_iter: or loosen eps:"
     (0...n).map{|i| [index_to_node[i], curr[i]] }.sort.to_h
   end
 end

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.2.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/networkx.gemspec

@@ -13,13 +13,15 @@ Gem::Specification.new do |spec|
   spec.email         = ['athityakumar@gmail.com']
   spec.summary       = 'A Ruby implemenation of the well-known graph library called networkx.'
   spec.description   = NetworkX::DESCRIPTION
-  spec.homepage      = 'https://github.com/athityakumar/networkx.rb'
+  spec.homepage      = 'https://github.com/SciRuby/networkx.rb'
   spec.license       = 'MIT'
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = 'bin'
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = '>= 2.7'
+
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
@@ -34,4 +36,6 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'matrix', '~> 0.4'
   spec.add_runtime_dependency 'rb_heap', '~> 1.0'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: networkx
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Athitya Kumar
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-25 00:00:00.000000000 Z
+date: 2022-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -207,7 +207,6 @@ files:
 - ".github/PULL_REQUEST_TEMPLATE.md"
 - ".github/workflows/ci.yml"
 - ".github/workflows/doc.yml"
-- ".github/workflows/gem-push.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -259,10 +258,11 @@ files:
 - lib/networkx/traversals/edge_dfs.rb
 - lib/networkx/version.rb
 - networkx.gemspec
-homepage: https://github.com/athityakumar/networkx.rb
+homepage: https://github.com/SciRuby/networkx.rb
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -271,7 +271,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.github/workflows/gem-push.yml

@@ -1,45 +0,0 @@
-name: Ruby Gem
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-    name: Build + Publish
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby 2.6
-      uses: actions/setup-ruby@v1
-      with:
-        ruby-version: 2.6.x
-
-    - name: Publish to GPR
-      run: |
-        mkdir -p $HOME/.gem
-        touch $HOME/.gem/credentials
-        chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:github: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-        gem build *.gemspec
-        gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
-      env:
-        GEM_HOST_API_KEY: "Bearer ${{secrets.GITHUB_TOKEN}}"
-        OWNER: ${{ github.repository_owner }}
-
-    - name: Publish to RubyGems
-      run: |
-        mkdir -p $HOME/.gem
-        touch $HOME/.gem/credentials
-        chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-        gem build *.gemspec
-        gem push *.gem
-      env:
-        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"