Get cholmod working with python3 (#17)

- Remove reliance on baiji for a single test asset - blmath.numerics.linalg.cholmod working in python 3 - Set up tox to run tests locally across python versions - Removed conditional import from OpenDR (and all references to OpenDR)
lace · Sep 20, 2019 · 03299a1 · 03299a1
1 parent 773f736
commit 03299a1
Show file tree

Hide file tree

Showing 19 changed files with 414 additions and 359 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,13 @@
 Changelog
 =========
 
+## 1.6.3 (Sep 9, 2019)
+
+- Remove reliance on baiji for a single test asset
+- blmath.numerics.linalg.cholmod working in python 3
+- Set up tox to run tests locally across python versions
+- Removed conditional import from OpenDR (and all references to OpenDR)
+
 ## 1.6.2 (Sep 9, 2019)
 
 - Merge Metabolize fork back into [original repo at its new home][repo].

diff --git a/README.md b/README.md
@@ -158,6 +158,15 @@ rake unittest
 rake lint
 ```
 
+Tests are configured to run in both python 2.7 and 3.6 locally via tox as well as in CircleCI.
+To run tests in multiple versions of python, run `tox`:
+
+```sh
+pip install -r requirements_dev.txt
+tox
+```
+
+You need to make sure that `python2.7` and `python3.6` are valid commands; this can be done in pyenv via `pyenv global 3.6.5 2.7.15`
 
 Contribute
 ----------

diff --git a/blmath/__init__.py b/blmath/__init__.py
@@ -1 +1 @@
-__version__ = '1.6.2'
+__version__ = '1.6.3'
diff --git a/blmath/cache.py b/blmath/cache.py
diff --git a/blmath/geometry/primitives/plane.py b/blmath/geometry/primitives/plane.py
@@ -1,6 +1,8 @@
+import six
 import numpy as np
 from blmath.numerics import vx
 
+
 class Plane(object):
     '''
     A 2-D plane in 3-space (not a hyperplane).
@@ -358,7 +360,7 @@ def pop_euler_path(self, allow_multiple_connected_components=True):
 
                 # counting the number of vertices with odd degree
                 odd = [x for x in self.d if len(self.d[x])&1]
-                odd.append(list(self.d.keys())[0])
+                odd.append(next(six.iterkeys(self.d)))
                 if not allow_multiple_connected_components and len(odd) > 3:
                     return None
                 stack = [odd[0]]

diff --git a/blmath/geometry/transform/rodrigues.py b/blmath/geometry/transform/rodrigues.py
@@ -1,20 +1,18 @@
 import numpy as np
 import chumpy as ch
 
-try:
-    from opendr.geometry import Rodrigues  # This lets us import blmath.geometry.normals.NormalizedNx3 etc. whether or not opendr is available. pylint: disable=unused-import
-except ImportError:
-    class Rodrigues(ch.Ch):
-        dterms = 'rt'
 
-        def compute_r(self):
-            import cv2
-            return cv2.Rodrigues(self.rt.r)[0]
+class Rodrigues(ch.Ch):
+    dterms = 'rt'
 
-        def compute_dr_wrt(self, wrt):
-            import cv2
-            if wrt is self.rt:
-                return cv2.Rodrigues(self.rt.r)[1].T
+    def compute_r(self):
+        import cv2
+        return cv2.Rodrigues(self.rt.r)[0]
+
+    def compute_dr_wrt(self, wrt):
+        import cv2
+        if wrt is self.rt:
+            return cv2.Rodrigues(self.rt.r)[1].T
 
 
 def rodrigues(r, calculate_jacobian=False):

diff --git a/blmath/numerics/linalg/cholmod.c b/blmath/numerics/linalg/cholmod.c
@@ -13,6 +13,10 @@ typedef long Int;
 #define NATURAL_ORDER 0
 #define LOWER_TRIANGULAR -1
 
+#if PY_MAJOR_VERSION >= 3
+#define PyInt_AsLong PyLong_AsLong
+#endif
+
 static PyObject * cholmod_lchol_c(PyObject *self, PyObject *args);
 
 static PyMethodDef CholmodMethods[] = {
@@ -115,12 +119,43 @@ void sputil_config (cholmod_common *cm)
     }
 }
 
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "cholmod",     /* m_name */
+    "cholmod methods",  /* m_doc */
+    -1,                  /* m_size */
+    CholmodMethods,    /* m_methods */
+    NULL,                /* m_reload */
+    NULL,                /* m_traverse */
+    NULL,                /* m_clear */
+    NULL,                /* m_free */
+};
+#endif
 
-PyMODINIT_FUNC
-initcholmod(void)
+#if PY_MAJOR_VERSION >= 3
+PyMODINIT_FUNC PyInit_cholmod(void)
+#else
+PyMODINIT_FUNC initcholmod(void)
+#endif
 {
-    (void) Py_InitModule("cholmod", CholmodMethods);
+    PyObject *m;
+
+#if PY_MAJOR_VERSION >= 3
+    m = PyModule_Create(&moduledef);
+    if (m == NULL)
+        return NULL;
+#else
+    m = Py_InitModule("cholmod", CholmodMethods);
+    if (m == NULL)
+        return;
+#endif
+
     import_array();
+
+#if PY_MAJOR_VERSION >= 3
+    return m;
+#endif
 }
 
 

diff --git a/blmath/numerics/linalg/cholmod.pkl b/blmath/numerics/linalg/cholmod.pkl
diff --git a/blmath/numerics/linalg/test_cholmod.py b/blmath/numerics/linalg/test_cholmod.py
@@ -1,55 +1,58 @@
+import os
 import unittest
-from baiji.serialization import pickle
+import six
+from six.moves import cPickle as pickle
 import numpy as np
 import scipy.sparse as sp
-from bltest import attr
-from blmath.cache import vc
 from blmath.numerics.linalg import lchol
 
-# class TestCholmod(unittest.TestCase):
-
-#     def test_random_cholmod(self):
-#         n_rows = 100
-#         A0 = 10*sp.rand(n_rows, n_rows, density=0.01, format='csc')
-#         A = A0*A0.transpose() + sp.eye(n_rows, n_rows)
-
-#         [L, L_nonpsd, S] = lchol.lchol(A)
-
-#         self.assertTrue(sum((abs(S.T.dot(A.dot(S))-L.dot(L.T))).data) < 1e-5)
-#         self.assertEqual(L_nonpsd, 0)
-
-#     # def test_memory_leak(self):
-#     #     n_rows = 3000
-#     #     A0 = 10*sp.rand(n_rows, n_rows, density=0.001, format='csc')
-#     #     A = A0*A0.transpose() + sp.eye(n_rows, n_rows)
-#     #     # mem0 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-#     #     for i in range(50):
-#     #         [chol_L, L_nonpsd, chol_S] = lchol.lchol(A)
-#     #         import gc
-#     #         gc.collect()
-#     #     # mem1 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-#     #     #print(mem1 - mem0)
-#     #     self.assertTrue(True)
-
-#     @attr('missing_assets')
-#     def test_cholmod(self):
-#         A, chol_L, _, cv = pickle.load(vc('/unittest/linalg/cholmod.pkl'))
-
-#         c_data = np.ones(len(cv))/len(cv)
-#         c_rows = cv.flatten()
-#         c_cols = (np.zeros(len(cv))).astype(np.int32)
-#         c = sp.csc_matrix((c_data, (c_rows, c_cols)), shape=(A.shape[0], 1))
-#         Ac = sp.hstack([A, c], format='csc')
-
-#         AAc = Ac.dot(Ac.T)
-
-#         [chol_L_comp, L_nonpsd, chol_S_comp] = lchol.lchol(AAc)
-
-#         right = chol_S_comp.T.dot(AAc.dot(chol_S_comp))
-#         left = chol_L_comp.dot(chol_L_comp.T)
-
-#         self.assertTrue(sum((abs(right-left)).data))  # it's a reordered LLt decomposition
-#         self.assertEqual(sp.triu(chol_L, k=1).nnz, 0) # it's lower triangular'
-#         self.assertEqual(L_nonpsd, 0)                 # the input is positive definite
-#         # self.assertTrue(sum((abs(chol_L - chol_L_comp)).data) < 1e-1)
-#         # self.assertTrue(sum((abs(chol_S - chol_S_comp)).data) < 1e-1)
+class TestCholmod(unittest.TestCase):
+
+    def test_random_cholmod(self):
+        n_rows = 100
+        A0 = 10*sp.rand(n_rows, n_rows, density=0.01, format='csc')
+        A = A0*A0.transpose() + sp.eye(n_rows, n_rows)
+
+        [L, L_nonpsd, S] = lchol.lchol(A)
+
+        self.assertTrue(sum((abs(S.T.dot(A.dot(S))-L.dot(L.T))).data) < 1e-5)
+        self.assertEqual(L_nonpsd, 0)
+
+    # def test_memory_leak(self):
+    #     n_rows = 3000
+    #     A0 = 10*sp.rand(n_rows, n_rows, density=0.001, format='csc')
+    #     A = A0*A0.transpose() + sp.eye(n_rows, n_rows)
+    #     # mem0 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+    #     for i in range(50):
+    #         [chol_L, L_nonpsd, chol_S] = lchol.lchol(A)
+    #         import gc
+    #         gc.collect()
+    #     # mem1 = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+    #     #print(mem1 - mem0)
+    #     self.assertTrue(True)
+
+    def test_cholmod(self):
+        test_pkl_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'cholmod.pkl')
+        pickle_kwargs = {}
+        if six.PY3:
+            pickle_kwargs['encoding'] = 'latin1'
+        A, chol_L, _, cv = pickle.load(open(test_pkl_path, 'rb'), **pickle_kwargs)
+
+        c_data = np.ones(len(cv))/len(cv)
+        c_rows = cv.flatten()
+        c_cols = (np.zeros(len(cv))).astype(np.int32)
+        c = sp.csc_matrix((c_data, (c_rows, c_cols)), shape=(A.shape[0], 1))
+        Ac = sp.hstack([A, c], format='csc')
+
+        AAc = Ac.dot(Ac.T)
+
+        [chol_L_comp, L_nonpsd, chol_S_comp] = lchol.lchol(AAc)
+
+        right = chol_S_comp.T.dot(AAc.dot(chol_S_comp))
+        left = chol_L_comp.dot(chol_L_comp.T)
+
+        self.assertTrue(sum((abs(right-left)).data))  # it's a reordered LLt decomposition
+        self.assertEqual(sp.triu(chol_L, k=1).nnz, 0) # it's lower triangular'
+        self.assertEqual(L_nonpsd, 0)                 # the input is positive definite
+        # self.assertTrue(sum((abs(chol_L - chol_L_comp)).data) < 1e-1)
+        # self.assertTrue(sum((abs(chol_S - chol_S_comp)).data) < 1e-1)
diff --git a/blmath/numerics/test_coercion.py b/blmath/numerics/test_coercion.py
@@ -1,4 +1,5 @@
 import unittest
+import warnings
 import numpy as np
 
 class TestCoercion(unittest.TestCase):
@@ -42,7 +43,11 @@ def test_as_numeric_array_three_by_one(self):
                 as_numeric_array(v, shape=(3,), allow_none=False)
 
         for v in good_iff_allow_none_and_empty_as_none:
-            as_numeric_array(v, shape=(3,), allow_none=True, empty_as_none=True)
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always")
+                as_numeric_array(v, shape=(3,), allow_none=True, empty_as_none=True)
+                assert len(w) == 1
+                assert issubclass(w[-1].category, DeprecationWarning)
             with self.assertRaises(ValueError):
                 as_numeric_array(v, shape=(3,), allow_none=False, empty_as_none=True)
 

diff --git a/blmath/numerics/test_vector_shortcuts.py b/blmath/numerics/test_vector_shortcuts.py
@@ -191,14 +191,14 @@ def test_pad_with_ones(self):
 
     def test_pad_with_wrong_dimensions(self):
         # NB: on windows, the sizes here will render as 3L, not 3:
-        with self.assertRaisesRegexp(ValueError, '^Invalid shape \(3L?, 4L?\): pad expects nx3$'): # FIXME pylint: disable=anomalous-backslash-in-string
+        with self.assertRaisesRegexp(ValueError, r'^Invalid shape \(3L?, 4L?\): pad expects nx3$'): # FIXME pylint: disable=anomalous-backslash-in-string
             vx.pad_with_ones(np.array([
                 [1., 2., 3., 42.],
                 [2., 3., 4., 42.],
                 [5., 6., 7., 42.],
             ]))
 
-        with self.assertRaisesRegexp(ValueError, '^Invalid shape \(3L?,\): pad expects nx3$'): # FIXME pylint: disable=anomalous-backslash-in-string
+        with self.assertRaisesRegexp(ValueError, r'^Invalid shape \(3L?,\): pad expects nx3$'): # FIXME pylint: disable=anomalous-backslash-in-string
             vx.pad_with_ones(np.array([1., 2., 3.]))
 
     def test_unpad(self):
@@ -216,14 +216,14 @@ def test_unpad(self):
         )
 
         # NB: on windows, the sizes here will render as 3L, not 3:
-        with self.assertRaisesRegexp(ValueError, '^Invalid shape \(3L?, 3L?\): unpad expects nx4$'): # FIXME pylint: disable=anomalous-backslash-in-string
+        with self.assertRaisesRegexp(ValueError, r'^Invalid shape \(3L?, 3L?\): unpad expects nx4$'): # FIXME pylint: disable=anomalous-backslash-in-string
             vx.unpad(np.array([
                 [1., 2., 3.],
                 [2., 3., 4.],
                 [5., 6., 7.],
             ]))
 
-        with self.assertRaisesRegexp(ValueError, '^Invalid shape \(4L?,\): unpad expects nx4$'): # FIXME pylint: disable=anomalous-backslash-in-string
+        with self.assertRaisesRegexp(ValueError, r'^Invalid shape \(4L?,\): unpad expects nx4$'): # FIXME pylint: disable=anomalous-backslash-in-string
             vx.unpad(np.array([1., 2., 3., 4.]))
 
         with self.assertRaisesRegexp(ValueError, '^Expected a column of ones$'):