NF+TST: added tools to convert different formats of partition.index, partition.community for refactor of code

Author: CindeeM

brainx/tests/test_util.py

@@ -17,6 +17,46 @@
 # Functions
 #-----------------------------------------------------------------------------
 
+def make_testlists():
+    listlist = [[0,1,2],[3,4,5],[6,7,8,9]]
+    dictset = {val:set(item) for val, item in enumerate(listlist)}
+    listset = [set(item) for item in listlist]
+    return listlist, listset, dictset 
+
+def test_dictset_to_listset():
+    _, listset, dictset = make_testlists()
+    new_list_set = util.dictset_to_listset(dictset)
+    npt.assert_equal(new_list_set, listset)
+    with npt.assert_raises(ValueError):
+        tmp = util.dictset_to_listset(listset)
+
+def test_listset_to_dictset():
+    _, listset, dictset = make_testlists()
+    new_dict_set = util.listset_to_dictset(listset)
+    npt.assert_equal(new_dict_set, dictset)
+    # capture wrong input type
+    with npt.assert_raises(ValueError):
+        tmp = util.listset_to_dictset(dictset)
+
+def test_no_repeats_in_listlist():
+    jnk = [[0,1,2],[3,4,5]] # all unique
+    nt.assert_true(util._no_repeats_in_listlist(jnk))
+    jnk = [[0,1,2], [0,1,2]]
+    nt.assert_false(util._no_repeats_in_listlist(jnk))
+    with npt.assert_raises(ValueError):
+        util._no_repeats_in_listlist({0:0})
+    with npt.assert_raises(ValueError):
+        util._no_repeats_in_listlist([set([0,1,2])])
+
+def test_listlist_to_listset():
+    listlist, listset, _ = make_testlists()
+    new_listset = util.listlist_to_listset(listlist)
+    npt.assert_equal(new_listset, listset)
+    with npt.assert_raises(ValueError):
+        util.listlist_to_listset([[0,1,2],[0,1,2]])
+    with npt.assert_raises(ValueError):
+        util.listlist_to_listset({})
+
 def test_slice_data():
     subcond, blocks, subjects, nodes = 5, 10, 20, 4 
     data_4d = np.ones((blocks, subjects, nodes, nodes))

brainx/util.py

@@ -12,6 +12,43 @@
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
+
+def dictset_to_listset(dict_set):
+    """ converts a dict of sets to a list of sets
+    for converting partition.community objects"""
+    if  (type(dict_set) == type({}) \
+        and all(type(x) == type(set()) for x in dict_set.values())):
+        return dict_set.values()
+        
+    raise ValueError('{0} is not a dict of sets'.format(dict_set))
+   
+def listset_to_dictset(list_set):
+    """ converts a list of sets to a dict of sets
+    for converting partition.community objects"""
+    ## check input is dict of sets
+    if (type(list_set)==type([]) and \
+        all(type(x) == type(set()) for x in list_set)):
+        return {val: value for val, value in enumerate(list_set)}
+    raise ValueError('{0} is not a list of sets'.format(list_set))
+
+def _no_repeats_in_listlist(list_list):
+    """ checks for duplicates in list of lists
+    returns True or False"""
+    if type(list_list) == type([]) and \
+        all(type(x) == type([]) for x in list_list):
+        allitems = [item for sublist in list_list for item in sublist]
+        return sorted(allitems) == [x for x in sorted(set(allitems))] 
+    raise ValueError('{0} is not a list of lists'.format(list_list))
+
+def listlist_to_listset(list_list):
+    """ converts list of lists to a list of sets (with check)
+    for converting partition.community objects"""
+    if _no_repeats_in_listlist(list_list):
+        return [set(x) for x in list_list] 
+    else:
+        raise ValueError('found duplicate(s) in {0}, cannot validly format to '\
+            'list of sets'.format(list_list))
+
 def slice_data(data, sub, block, subcond=None):
     """ pull symmetric matrix from data block (4D or 5D)