Merge pull request #18 from cindeem/add_util

NF+TST: conversion tools for refactor of GraphPartition

Author: cindeem

brainx/tests/test_util.py

@@ -17,6 +17,57 @@
 # Functions
 #-----------------------------------------------------------------------------
 
+def make_testlists():
+    """ setup some data for the conversion Tests
+    eg lislist_to_listset"""
+    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):
+        # catch bad type
+        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]] # repeats
+    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_contains_only():
+    listlist, listset, dictset = make_testlists()
+    nt.assert_true(util._contains_only(listlist, list))
+    nt.assert_true(util._contains_only(listset, set))
+    nt.assert_true(util._contains_only(dictset, set))
+    nt.assert_false(util._contains_only([1,2,3], set))
+
+
+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,52 @@
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
+
+def dictset_to_listset(dict_set):
+    """ converts a dict of sets to a list of sets
+    for converting partition.community objects"""
+    if  isinstance(dict_set, dict) \
+        and _contains_only(dict_set, set):
+        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 isinstance(list_set, list) and \
+        _contains_only(list_set, 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 isinstance(list_list, list) and \
+        _contains_only(list_list, list):
+        allitems = [item for sublist in list_list for item in sublist]
+        return len(allitems) == len(set(allitems))
+    raise ValueError('{0} is not a list of lists'.format(list_list))
+
+def _contains_only(container, type):
+    """check that contents of a container are all of the same type"""
+    try:
+        container = container.values()  # dict
+    except AttributeError:
+        pass
+
+    return all(isinstance(s, type) for s in container)
+
+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)