no edges now will raise an error when trying to partition using Louvain

Author: CindeeM

brainx/tests/test_weighted_modularity.py

@@ -90,8 +90,8 @@ def test_get_node_community(self):
         self.assertEqual(part.get_node_community(0), 0)
 
     def test_node_degree(self):
-        part = wm.WeightedPartition(self.graph) # one comm per node   
-        node = 0    
+        part = wm.WeightedPartition(self.graph) # one comm per node
+        node = 0
         res = part.node_degree(node)
         npt.assert_almost_equal(res, 37.94151675 )
 
@@ -113,8 +113,8 @@ def test_total_links(self):
 
     def test_internal_links(self):
         part = wm.WeightedPartition(self.graph) # one comm per node
-        weights = part.internal_links() 
-        ## this inlcudes self links so 
+        weights = part.internal_links()
+        ## this inlcudes self links so
         self.assertEqual(weights[0], 1.0)
 
 
@@ -123,7 +123,7 @@ def test_dnodecom(self):
         part = wm.WeightedPartition(self.graph) # one comm per node
         node = 0
         node2comm_weights = part.dnodecom(node)
-        # self loops not added to weight 
+        # self loops not added to weight
         # so communities made only of node should be zero
         npt.assert_equal(node2comm_weights[0],0)
         # this should be equal to weight between two nodes
@@ -132,7 +132,7 @@ def test_dnodecom(self):
         npt.assert_equal(node2comm_weights[neighbor],expected)
         part = wm.WeightedPartition(self.graph, self.communities)
         node2comm_weights = part.dnodecom(node)
-        npt.assert_equal(len(node2comm_weights), 2) 
+        npt.assert_equal(len(node2comm_weights), 2)
 
 
 class TestLouvainCommunityDetection(unittest.TestCase):
@@ -153,7 +153,7 @@ def test_init(self):
 
 
     def test_communities_without_node(self):
-        part = wm.WeightedPartition(self.graph) # one comm per node   
+        part = wm.WeightedPartition(self.graph) # one comm per node
         node = 0
         updated_comm = self.louvain._communities_without_node(part, node)
         self.assertEqual(updated_comm[0], set([]))
@@ -164,7 +164,7 @@ def test_communities_without_node(self):
         self.assertEqual(0 not in updated_comm[0], True)
 
     def test_communities_nodes_alledgesw(self):
-        part = wm.WeightedPartition(self.graph, self.communities)    
+        part = wm.WeightedPartition(self.graph, self.communities)
         node = 0
         weights = self.louvain_comm._communities_nodes_alledgesw(part, node)
         npt.assert_almost_equal(weights[0], 1424.0220362)
@@ -186,31 +186,28 @@ def test_calc_delta_modularity(self):
         self.assertEqual(change[0] < change[1], True)
         # this is one comm per node, so once removed from own
         # comm, this delta_weight will be zero
-        self.assertEqual(change[node] , 0) 
+        self.assertEqual(change[node] , 0)
 
     def test_move_node(self):
-        part = wm.WeightedPartition(self.graph) # one comm per node 
-        #move first node to second community 
+        part = wm.WeightedPartition(self.graph) # one comm per node
+        #move first node to second community
         node = 0
         comm = 1
         newpart = self.louvain._move_node(part, node, comm)
         self.assertEqual(set([0,1]) in newpart.communities, True)
         ## what happens if node or comm missing
         with self.assertRaises(ValueError):
-            newpart = self.louvain._move_node(part, -1, comm) 
+            newpart = self.louvain._move_node(part, -1, comm)
         invalid_communities = len(part.communities) + 1
         with self.assertRaises(IndexError):
-            newpart = self.louvain._move_node(part, node, invalid_communities) 
+            newpart = self.louvain._move_node(part, node, invalid_communities)
 
     def test_gen_dendogram(self):
-        graph = nx.Graph() 
+        graph = nx.Graph()
         nodeslist = [0,1,2,3,4]
         graph.add_nodes_from(nodeslist, weight=True)
         louvain = wm.LouvainCommunityDetection(graph)
-        dendo = louvain.gen_dendogram()
-        self.assertEqual(len(dendo), 1)
-        expected = [set([x]) for x in nodeslist]
-        self.assertEqual(dendo[0].communities, expected)
+        self.assertRaises(IOError, louvain.gen_dendogram)
 
     def test_run(self):
         karate = nx.karate_club_graph()

brainx/weighted_modularity.py

@@ -10,15 +10,15 @@ class WeightedPartition(object):
     """Represent a weighted Graph Partition
 
        The main object keeping track of the nodes in each partition is the
-       communities attribute. 
+       communities attribute.
     """
     def __init__(self, graph, communities=None):
         """ initialize partition of graph, with optional communities
 
         Parameters
         ----------
         graph : networkx graph
-        
+
         communities : list of sets, optional
             a list of sets with nodes in each set
             if communities is None, will initialize with
@@ -86,7 +86,7 @@ def _allnodes_in_communities(self, communities):
         if not (isinstance(communities, list) and \
             util._contains_only(communities, set)):
             raise TypeError('communities should be list of sets, not '\
-                '{}'.format(communities))  
+                '{}'.format(communities))
         ## simple count to check for all nodes
         return len(self.graph.nodes()) == \
             len([item for com in communities for item in com])
@@ -140,7 +140,7 @@ def internal_links(self):
 
 
     def modularity(self):
-        """Calculates the proportion of within community edges compared to 
+        """Calculates the proportion of within community edges compared to
         between community edges for all nodes in graph with given partition
 
         Parameters
@@ -157,12 +157,12 @@ def modularity(self):
         References
         ----------
         .. [1] M. Newman, "Fast algorithm for detecting community structure
-            in networks", Physical Review E vol. 69(6), 2004. 
+            in networks", Physical Review E vol. 69(6), 2004.
 
         """
         if self.graph.is_directed():
             raise TypeError('only valid on non directed graphs')
-        
+
         m2 = self.total_edge_weight
         internal_connect = np.array(self.internal_links())
         total = np.array(self.total_links())
@@ -178,7 +178,7 @@ class LouvainCommunityDetection(object):
     ----------
     graph : netwrokx Graph object
     communities : list of sets, optional
-        initial identified communties 
+        initial identified communties
     minthr : float, optional
         minimum threshold value for change in modularity
         default(0.0000001)
@@ -192,9 +192,9 @@ class LouvainCommunityDetection(object):
 
     References
     ----------
-    .. [1] VD Blondel, JL Guillaume, R Lambiotte, E Lefebvre, "Fast 
-        unfolding of communities in large networks", Journal of Statistical 
-        Mechanics: Theory and Experiment vol.10, P10008  2008. 
+    .. [1] VD Blondel, JL Guillaume, R Lambiotte, E Lefebvre, "Fast
+        unfolding of communities in large networks", Journal of Statistical
+        Mechanics: Theory and Experiment vol.10, P10008  2008.
 
     """
 
@@ -215,11 +215,11 @@ def gen_dendogram(self):
         if type(self.graph) != nx.Graph :
             raise TypeError("Bad graph type, use only non directed graph")
 
-        #special case, when there is no link 
+        #special case, when there is no link
         #the best partition is everyone in its communities
         if self.graph.number_of_edges() == 0 :
-            return [WeightedPartition(self.graph)]
-            
+            raise IOError('graph has no edges why do you want a partition?')
+
         current_graph = self.graph.copy()
         part = WeightedPartition(self.graph, self.initial_communities)
         # first pass
@@ -231,7 +231,7 @@ def gen_dendogram(self):
         dendogram.append(new_part)
         mod = new_mod
         current_graph, _ = meta_graph(new_part)
-        
+
         while True :
             partition = WeightedPartition(current_graph)
             newpart = self._one_level(partition, self.minthr)
@@ -260,7 +260,7 @@ def _one_level(self, part, min_modularity= .0000001):
                     # no increase by moving this node
                     continue
                 best_comm = delta_mod.argmax()
-                if not best_comm == node_comm: 
+                if not best_comm == node_comm:
                     new_part = self._move_node(part, node, best_comm)
                     part = new_part
                     modified = True
@@ -307,7 +307,7 @@ def _communities_nodes_alledgesw(self, part, removed_node):
             if len(node_index)<1:
                 continue
             weights[val] = np.sum(all_degree_weights[node_index])
-        return weights  
+        return weights
 
     @staticmethod
     def _move_node(part, node, new_comm):
@@ -337,17 +337,17 @@ def partitions_from_dendogram(dendo):
         return all_partitions
 
 
-            
+
 def meta_graph(partition):
     """ takes weighted partition communities and creates a new meta graph where
-    communities are now the nodes, the new edges are created based on the 
+    communities are now the nodes, the new edges are created based on the
     node to node connections from original graph, and weighted accordingly,
     this includes self-loops"""
     metagraph = nx.Graph()
     # new nodes are communities
     newnodes = [val for val,_ in enumerate(partition.communities)]
     mapping = {val:nodes for val,nodes in enumerate(partition.communities)}
-    metagraph.add_nodes_from(newnodes, weight=0.0) 
+    metagraph.add_nodes_from(newnodes, weight=0.0)
 
     for node1, node2, data in partition.graph.edges_iter(data=True):
         node1_community = partition.get_node_community(node1)