RF added contains_only to reduce repetition, simplify code based on @stefanv suggestions

Author: CindeeM

brainx/tests/test_util.py

@@ -18,6 +18,8 @@
 #-----------------------------------------------------------------------------
 
 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]
@@ -28,6 +30,7 @@ def test_dictset_to_listset():
     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():
@@ -41,13 +44,21 @@ def test_listset_to_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]]
+    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)

brainx/util.py

@@ -16,8 +16,8 @@
 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())):
+    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))
@@ -26,20 +26,29 @@ 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)):
+    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 type(list_list) == type([]) and \
-        all(type(x) == type([]) for x in list_list):
+    if isinstance(list_list, list) and \
+        _contains_only(list_list, list):
         allitems = [item for sublist in list_list for item in sublist]
-        return sorted(allitems) == [x for x in sorted(set(allitems))] 
+        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 fo the same type"""
+    try:
+        # dict
+        return all(isinstance(s, type) for s in container.values())
+    except:
+        # others
+        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"""