Merge branch 'release/1.2.1'

Author: exhuma

CHANGELOG

@@ -1,3 +1,6 @@
+1.2.1
+   - Fixed an issue in multiprocessing code.
+
 1.2.0
    - Multiprocessing (by loisaidasam)
    - Python 3 support

INSTALL

@@ -18,7 +18,7 @@ Untar the archive::
    tar xf <filename.tar.gz>
 
 Next, go to the folder just created. It will have the same name as the package
-(for example "cluster-1.2.0") and run::
+(for example "cluster-1.2.1") and run::
 
     python setup.py install
 

README.rst

@@ -1,6 +1,10 @@
 DESCRIPTION
 ===========
 
+.. image:: https://readthedocs.org/projects/python-cluster/badge/?version=latest
+    :target: http://python-cluster.readthedocs.org
+    :alt: Documentation Status
+
 python-cluster is a "simple" package that allows to create several groups
 (clusters) of objects from a list. It's meant to be flexible and able to
 cluster any object. To ensure this kind of flexibility, you need not only to
@@ -44,3 +48,8 @@ For K-Means clustering it would look like this::
     >>> clusters = cl.getclusters(2)
 
 The parameter passed to getclusters is the count of clusters generated.
+
+
+.. image:: https://readthedocs.org/projects/python-cluster/badge/?version=latest
+    :target: http://python-cluster.readthedocs.org
+    :alt: Documentation Status

cluster/matrix.py

@@ -58,10 +58,8 @@ def worker(self):
         for task in iter(self.task_queue.get, 'STOP'):
             col_index, item, item2 = task
             result = (col_index, self.combinfunc(item, item2))
-            self.task_queue.task_done()
             self.done_queue.put(result)
             tasks_completed += 1
-        self.task_queue.task_done()
         logger.info("Worker %s performed %s tasks",
                     current_process().name,
                     tasks_completed)
@@ -117,7 +115,6 @@ def genmatrix(self, num_processes=1):
                     # blocking operation)
                     if num_tasks_queued > num_processes:
                         col_index, result = self.done_queue.get()
-                        self.done_queue.task_done()
                         row[col_index] = result
                         num_tasks_completed += 1
                 else:
@@ -136,7 +133,6 @@ def genmatrix(self, num_processes=1):
                 # Grab the remaining worker task results
                 while num_tasks_completed < num_tasks_queued:
                     col_index, result = self.done_queue.get()
-                    self.done_queue.task_done()
                     row[col_index] = result
                     num_tasks_completed += 1
 

setup.py

@@ -10,7 +10,7 @@
 
 setup(
     name='cluster',
-    version='1.2.0',
+    version='1.2.1',
     author='Michel Albert',
     author_email='[email protected]',
     url='https://github.com/exhuma/python-cluster',

test.py

@@ -73,27 +73,104 @@ def setUp(self):
         self.__data = [791, 956, 676, 124, 564, 84, 24, 365, 594, 940, 398,
                        971, 131, 365, 542, 336, 518, 835, 134, 391]
 
-    def testCluster(self):
+    def testSingleLinkage(self):
         "Basic Hierarchical Clustering test with integers"
         cl = HierarchicalClustering(self.__data, lambda x, y: abs(x - y))
-        cl.cluster()
+        result = cl.getlevel(40)
+
+        # sort the values to make the tests less prone to algorithm changes
+        result = sorted([sorted(_) for _ in result])
         self.assertEqual([
             [24],
             [84, 124, 131, 134],
             [336, 365, 365, 391, 398],
+            [518, 542, 564, 594],
             [676],
-            [594, 518, 542, 564],
+            [791],
+            [835],
             [940, 956, 971],
+        ], result)
+
+    def testCompleteLinkage(self):
+        "Basic Hierarchical Clustering test with integers"
+        cl = HierarchicalClustering(self.__data,
+                                    lambda x, y: abs(x - y),
+                                    linkage='complete')
+        result = cl.getlevel(40)
+
+        # sort the values to make the tests less prone to algorithm changes
+        result = sorted([sorted(_) for _ in result])
+
+        expected = [
+            [24],
+            [84],
+            [124, 131, 134],
+            [336, 365, 365],
+            [391, 398],
+            [518],
+            [542, 564],
+            [594],
+            [676],
             [791],
             [835],
-        ], cl.getlevel(40))
+            [940, 956, 971],
+        ]
+        self.assertEqual(result, expected)
+
+    def testUCLUS(self):
+        "Basic Hierarchical Clustering test with integers"
+        cl = HierarchicalClustering(self.__data,
+                                    lambda x, y: abs(x - y),
+                                    linkage='uclus')
+        expected = [
+            [24],
+            [84],
+            [124, 131, 134],
+            [336, 365, 365, 391, 398],
+            [518, 542, 564],
+            [594],
+            [676],
+            [791],
+            [835],
+            [940, 956, 971],
+        ]
+        result = sorted([sorted(_) for _ in cl.getlevel(40)])
+        self.assertEqual(result, expected)
+
+    def testAverageLinkage(self):
+        cl = HierarchicalClustering(self.__data,
+                                    lambda x, y: abs(x - y),
+                                    linkage='average')
+        # TODO: The current test-data does not really trigger a difference
+        # between UCLUS and "average" linkage.
+        expected = [
+            [24],
+            [84],
+            [124, 131, 134],
+            [336, 365, 365, 391, 398],
+            [518, 542, 564],
+            [594],
+            [676],
+            [791],
+            [835],
+            [940, 956, 971],
+        ]
+        result = sorted([sorted(_) for _ in cl.getlevel(40)])
+        self.assertEqual(result, expected)
 
     def testUnmodifiedData(self):
         cl = HierarchicalClustering(self.__data, lambda x, y: abs(x - y))
         new_data = []
         [new_data.extend(_) for _ in cl.getlevel(40)]
         self.assertEqual(sorted(new_data), sorted(self.__data))
 
+    def testMultiprocessing(self):
+        cl = HierarchicalClustering(self.__data, lambda x, y: abs(x - y),
+                                    num_processes=4)
+        new_data = []
+        [new_data.extend(_) for _ in cl.getlevel(40)]
+        self.assertEqual(sorted(new_data), sorted(self.__data))
+
 
 class HClusterStringTestCase(unittest.TestCase):