PEP8 conformity

git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/ST_cythonize@1195 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: 8d2e24e07694508853feb677e5fd2294a663a2d5

13 files changed, 434 insertions, 284 deletions

diff --git a/src/cython/example/Alpha_complex_example.py b/src/cython/example/Alpha_complex_example.py
index cf5eed55..a724b0c4 100755
--- a/src/cython/example/Alpha_complex_example.py
+++ b/src/cython/example/Alpha_complex_example.py
@@ -2,44 +2,44 @@
 
 import gudhi
 
-print("#######################################################################")
+print("#####################################################################")
 print("AlphaComplex creation from points")
-alpha_complex = gudhi.AlphaComplex(points=[[0,0],[1,0],[0,1],[1,1]], max_alpha_square=60.0)
+alpha_complex = gudhi.AlphaComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]],
+                                   max_alpha_square=60.0)
 
-if alpha_complex.find([0,1]):
-  print("[0,1] Found !!")
+if alpha_complex.find([0, 1]):
+    print("[0, 1] Found !!")
 else:
-  print("[0,1] Not found...")
+    print("[0, 1] Not found...")
 
 if alpha_complex.find([4]):
-  print("[4] Found !!")
+    print("[4] Found !!")
 else:
-  print("[4] Not found...")
+    print("[4] Not found...")
 
-if alpha_complex.insert([0,1,2], filtration=4.0):
-  print("[0,1,2] Inserted !!")
+if alpha_complex.insert([0, 1, 2], filtration=4.0):
+    print("[0, 1, 2] Inserted !!")
 else:
-  print("[0,1,2] Not inserted...")
+    print("[0, 1, 2] Not inserted...")
 
-if alpha_complex.insert([0,1,4], filtration=4.0):
-  print("[0,1,4] Inserted !!")
+if alpha_complex.insert([0, 1, 4], filtration=4.0):
+    print("[0, 1, 4] Inserted !!")
 else:
-  print("[0,1,4] Not inserted...")
+    print("[0, 1, 4] Not inserted...")
 
 if alpha_complex.find([4]):
-  print("[4] Found !!")
+    print("[4] Found !!")
 else:
-  print("[4] Not found...")
+    print("[4] Not found...")
 
 print("dimension=", alpha_complex.dimension())
 print("filtered_tree=", alpha_complex.get_filtered_tree())
 print("star([0])=", alpha_complex.get_star_tree([0]))
-print("coface([0],1)=", alpha_complex.get_coface_tree([0], 1))
+print("coface([0], 1)=", alpha_complex.get_coface_tree([0], 1))
 
 print("point[0]=", alpha_complex.get_point(0))
 print("point[5]=", alpha_complex.get_point(5))
 
 alpha_complex.initialize_filtration()
-print("persistence(2)=", alpha_complex.persistence(2))
-
-print("#######################################################################")
+print("persistence(2)=", alpha_complex.persistence(homology_coeff_field=2,
+                                                   min_persistence=0))
diff --git a/src/cython/example/Mini_simplex_tree_example.py b/src/cython/example/Mini_simplex_tree_example.py
index 87407317..6cd5bf29 100755
--- a/src/cython/example/Mini_simplex_tree_example.py
+++ b/src/cython/example/Mini_simplex_tree_example.py
@@ -2,7 +2,7 @@
 
 import gudhi
 
-print("#######################################################################")
+print("#####################################################################")
 print("MiniSimplexTree creation from insertion")
 
 """ Complex to build.
@@ -10,7 +10,8 @@ print("MiniSimplexTree creation from insertion")
      o---o
     /X\ /
    o---o   o
-   2   0   4 """
+   2   0   4
+"""
 
 triangle012 = [0, 1, 2]
 edge03 = [0, 3]
@@ -23,7 +24,7 @@ mini_st.insert(edge13)
 mini_st.insert(vertex4)
 
 # FIXME: Remove this line
-mini_st.set_dimension(2);
+mini_st.set_dimension(2)
 
 # initialize_filtration required before plain_homology
 mini_st.initialize_filtration()
@@ -32,12 +33,12 @@ print("plain_homology(2)=", mini_st.plain_homology(2))
 
 edge02 = [0, 2]
 if mini_st.find(edge02):
-  # Only coface is 012
-  print("coface(edge02,1)=", mini_st.get_coface_tree(edge02, 1))
+    # Only coface is 012
+    print("coface(edge02,1)=", mini_st.get_coface_tree(edge02, 1))
 
 if mini_st.get_coface_tree(triangle012, 1) == []:
-  # Precondition: Check the simplex has no coface before removing it.
-  mini_st.remove_maximal_simplex(triangle012)
+    # Precondition: Check the simplex has no coface before removing it.
+    mini_st.remove_maximal_simplex(triangle012)
 
 # initialize_filtration required after removing
 mini_st.initialize_filtration()
diff --git a/src/cython/example/Rips_complex_example.py b/src/cython/example/Rips_complex_example.py
index 4713b62b..6a39fc77 100755
--- a/src/cython/example/Rips_complex_example.py
+++ b/src/cython/example/Rips_complex_example.py
@@ -2,12 +2,14 @@
 
 import gudhi
 
-print("#######################################################################")
+print("#####################################################################")
 print("RipsComplex creation from points")
-rips = gudhi.RipsComplex(points=[[0,0],[1,0],[0,1],[1,1]],max_dimension=1,max_edge_length=42)
+rips = gudhi.RipsComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]],
+                         max_dimension=1, max_edge_length=42)
 
 print("filtered_tree=", rips.get_filtered_tree())
 print("star([0])=", rips.get_star_tree([0]))
-print("coface([0],1)=", rips.get_coface_tree([0], 1))
+print("coface([0], 1)=", rips.get_coface_tree([0], 1))
 
-print("persistence(2)=", rips.persistence(2))
+print("persistence(2)=", rips.persistence(homology_coeff_field=2,
+                                          min_persistence=0))
diff --git a/src/cython/example/Simplex_tree_example.py b/src/cython/example/Simplex_tree_example.py
index fa40fbe6..e8585d83 100755
--- a/src/cython/example/Simplex_tree_example.py
+++ b/src/cython/example/Simplex_tree_example.py
@@ -4,22 +4,22 @@ import gudhi
 
 st = gudhi.SimplexTree()
 
-print("#######################################################################")
+print("#####################################################################")
 print("SimplexTree creation from insertion")
-if st.insert([0,1]):
-  print("Inserted !!")
+if st.insert([0, 1]):
+    print("Inserted !!")
 else:
-  print("Not inserted...")
+    print("Not inserted...")
 
-if st.find([0,1]):
-  print("Found !!")
+if st.find([0, 1]):
+    print("Found !!")
 else:
-  print("Not found...")
+    print("Not found...")
 
-if st.insert([0,1,2], filtration=4.0):
-  print("Inserted !!")
+if st.insert([0, 1, 2], filtration=4.0):
+    print("Inserted !!")
 else:
-  print("Not inserted...")
+    print("Not inserted...")
 
 # FIXME: Remove this line
 st.set_dimension(3)
@@ -28,8 +28,8 @@ print("dimension=", st.dimension())
 st.set_filtration(4.0)
 st.initialize_filtration()
 print("filtration=", st.get_filtration())
-print("filtration[1,2]=", st.filtration([1,2]))
-print("filtration[4,2]=", st.filtration([4,2]))
+print("filtration[1, 2]=", st.filtration([1, 2]))
+print("filtration[4, 2]=", st.filtration([4, 2]))
 
 print("num_simplices=", st.num_simplices())
 print("num_vertices=", st.num_vertices())
@@ -38,4 +38,5 @@ print("skeleton_tree[2]=", st.get_skeleton_tree(2))
 print("skeleton_tree[1]=", st.get_skeleton_tree(1))
 print("skeleton_tree[0]=", st.get_skeleton_tree(0))
 
-print("persistence(2)=", st.persistence(2))
+print("persistence(2)=", st.persistence(homology_coeff_field=2,
+                                        min_persistence=0))
diff --git a/src/cython/src/cpp/Persistent_cohomology_interface.h b/src/cython/src/cpp/Persistent_cohomology_interface.h
index 74410333..adfca638 100644
--- a/src/cython/src/cpp/Persistent_cohomology_interface.h
+++ b/src/cython/src/cpp/Persistent_cohomology_interface.h
@@ -32,15 +32,11 @@ class Persistent_cohomology_interface : public
 persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp> {
  public:
   Persistent_cohomology_interface(FilteredComplex* stptr)
-  : persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>(*stptr) { std::cout << "ctor" << std::endl; }
+  : persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>(*stptr) { }
   void get_persistence(int homology_coeff_field, double min_persistence) {
-    std::cout << "1" << std::endl; 
     persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>::init_coefficients(homology_coeff_field);
-    std::cout << "2" << std::endl; 
     persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>::compute_persistent_cohomology(min_persistence);
-    std::cout << "3" << std::endl; 
     persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>::output_diagram();
-    std::cout << "4" << std::endl; 
   }
 
 };
diff --git a/src/cython/src/cython/Alpha_complex.pyx b/src/cython/src/cython/Alpha_complex.pyx
index 8d08af42..a06134c8 100644
--- a/src/cython/src/cython/Alpha_complex.pyx
+++ b/src/cython/src/cython/Alpha_complex.pyx
@@ -1,3 +1,7 @@
+from cython cimport numeric
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+
 """This file is part of the Gudhi Library. The Gudhi library
    (Geometric Understanding in Higher Dimensions) is a generic C++
    library for computational topology.
@@ -17,19 +21,16 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>."""
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
 
-__author__      = "Vincent Rouvreau"
-__copyright__   = "Copyright (C) 2016  INRIA Saclay (France)"
-__license__     = "GPL v3"
-
-from cython cimport numeric
-from libcpp.vector cimport vector
-from libcpp.utility cimport pair
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016  INRIA Saclay (France)"
+__license__ = "GPL v3"
 
 cdef extern from "Alpha_complex_interface.h" namespace "Gudhi":
     cdef cppclass Alpha_complex_interface "Gudhi::alphacomplex::Alpha_complex_interface":
-        Alpha_complex_interface(vector[vector[double]] points,double max_alpha_square)
+        Alpha_complex_interface(vector[vector[double]] points, double max_alpha_square)
         double filtration()
         double simplex_filtration(vector[int] simplex)
         void set_filtration(double filtration)
@@ -39,103 +40,131 @@ cdef extern from "Alpha_complex_interface.h" namespace "Gudhi":
         void set_dimension(int dimension)
         int dimension()
         bint find_simplex(vector[int] simplex)
-        bint insert_simplex_and_subfaces(vector[int] simplex, double filtration)
+        bint insert_simplex_and_subfaces(vector[int] simplex,
+                                         double filtration)
         vector[pair[vector[int], double]] get_filtered_tree()
         vector[pair[vector[int], double]] get_skeleton_tree(int dimension)
         vector[pair[vector[int], double]] get_star_tree(vector[int] simplex)
-        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension)
+        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex,
+                                                          int dimension)
         void remove_maximal_simplex(vector[int] simplex)
         vector[double] get_point(int vertex)
 
 cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi":
     cdef cppclass Alpha_complex_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::alphacomplex::Alpha_complex< CGAL::Epick_d< CGAL::Dynamic_dimension_tag > >>":
-        Alpha_complex_persistence_interface(Alpha_complex_interface* st)
+        Alpha_complex_persistence_interface(Alpha_complex_interface * st)
         void get_persistence(int homology_coeff_field, double min_persistence)
 
 # AlphaComplex python interface
 cdef class AlphaComplex:
-    cdef Alpha_complex_interface *thisptr
+    cdef Alpha_complex_interface * thisptr
+
     def __cinit__(self, points=None, max_alpha_square=float('inf')):
         if points is not None:
-            self.thisptr = new Alpha_complex_interface(points, max_alpha_square)
+            self.thisptr = new Alpha_complex_interface(points,
+                                                       max_alpha_square)
+
     def __dealloc__(self):
         if self.thisptr != NULL:
             del self.thisptr
+
     def get_filtration(self):
         return self.thisptr.filtration()
+
     def filtration(self, simplex):
         return self.thisptr.simplex_filtration(simplex)
+
     def set_filtration(self, filtration):
-        self.thisptr.set_filtration(<double>filtration)
+        self.thisptr.set_filtration(<double> filtration)
+
     def initialize_filtration(self):
         self.thisptr.initialize_filtration()
+
     def num_vertices(self):
         return self.thisptr.num_vertices()
+
     def num_simplices(self):
         return self.thisptr.num_simplices()
+
     def dimension(self):
         return self.thisptr.dimension()
+
     def set_dimension(self, dim):
         self.thisptr.set_dimension(<int>dim)
+
     def find(self, simplex):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
+            complex.push_back(i)
         return self.thisptr.find_simplex(complex)
-    def insert(self, simplex, filtration = 0.0):
+
+    def insert(self, simplex, filtration=0.0):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration)
+            complex.push_back(i)
+        return self.thisptr.insert_simplex_and_subfaces(complex,
+                                                        <double>filtration)
+
     def get_filtered_tree(self):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree()
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_filtered_tree()
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_skeleton_tree(self, dim):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_skeleton_tree(<int>dim)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_star_tree(self, simplex):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex)
+            complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_star_tree(complex)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_coface_tree(self, simplex, dim):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim)
+            complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_coface_tree(complex, <int>dim)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def remove_maximal_simplex(self, simplex):
         self.thisptr.remove_maximal_simplex(simplex)
+
     def get_point(self, vertex):
         cdef vector[double] point = self.thisptr.get_point(vertex)
         return point
-    def persistence(self, homology_coeff_field, min_persistence = 0):
-        cdef Alpha_complex_persistence_interface *pcohptr = new Alpha_complex_persistence_interface(self.thisptr)
+
+    def persistence(self, homology_coeff_field=11, min_persistence=0):
+        cdef Alpha_complex_persistence_interface * pcohptr \
+            = new Alpha_complex_persistence_interface(self.thisptr)
         if pcohptr != NULL:
             pcohptr.get_persistence(homology_coeff_field, min_persistence)
             del pcohptr
diff --git a/src/cython/src/cython/Mini_simplex_tree.pyx b/src/cython/src/cython/Mini_simplex_tree.pyx
index b923b5b4..b836fb88 100644
--- a/src/cython/src/cython/Mini_simplex_tree.pyx
+++ b/src/cython/src/cython/Mini_simplex_tree.pyx
@@ -1,3 +1,7 @@
+from cython cimport numeric
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+
 """This file is part of the Gudhi Library. The Gudhi library
    (Geometric Understanding in Higher Dimensions) is a generic C++
    library for computational topology.
@@ -17,19 +21,17 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>."""
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
 
-__author__      = "Vincent Rouvreau"
-__copyright__   = "Copyright (C) 2016  INRIA Saclay (France)"
-__license__     = "GPL v3"
-
-from cython cimport numeric
-from libcpp.vector cimport vector
-from libcpp.utility cimport pair
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016  INRIA Saclay (France)"
+__license__ = "GPL v3"
 
 cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
     cdef cppclass Simplex_tree_options_mini:
         pass
+
     cdef cppclass Simplex_tree_interface_mini "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_mini>":
         Simplex_tree()
         double filtration()
@@ -41,99 +43,124 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         void set_dimension(int dimension)
         int dimension()
         bint find_simplex(vector[int] simplex)
-        bint insert_simplex_and_subfaces(vector[int] simplex, double filtration)
+        bint insert_simplex_and_subfaces(vector[int] simplex,
+                                         double filtration)
         vector[pair[vector[int], double]] get_filtered_tree()
         vector[pair[vector[int], double]] get_skeleton_tree(int dimension)
         vector[pair[vector[int], double]] get_star_tree(vector[int] simplex)
-        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension)
-        void graph_expansion(vector[vector[double]] points,int max_dimension,double max_edge_length)
+        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex,
+                                                          int dimension)
         void remove_maximal_simplex(vector[int] simplex)
 
 cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi":
     cdef cppclass Mini_simplex_tree_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_mini>>":
-        Mini_simplex_tree_persistence_interface(Simplex_tree_interface_mini* st)
+        Mini_simplex_tree_persistence_interface(Simplex_tree_interface_mini * st)
         void get_persistence(int homology_coeff_field, double min_persistence)
 
 # MiniSimplexTree python interface
 cdef class MiniSimplexTree:
-    cdef Simplex_tree_interface_mini *thisptr
+    cdef Simplex_tree_interface_mini * thisptr
+
     def __cinit__(self):
         self.thisptr = new Simplex_tree_interface_mini()
+
     def __dealloc__(self):
         if self.thisptr != NULL:
             del self.thisptr
+
     def get_filtration(self):
         return self.thisptr.filtration()
+
     def filtration(self, simplex):
         return self.thisptr.simplex_filtration(simplex)
+
     def set_filtration(self, filtration):
-        self.thisptr.set_filtration(<double>filtration)
+        self.thisptr.set_filtration(<double> filtration)
+
     def initialize_filtration(self):
         self.thisptr.initialize_filtration()
+
     def num_vertices(self):
         return self.thisptr.num_vertices()
+
     def num_simplices(self):
         return self.thisptr.num_simplices()
+
     def dimension(self):
         return self.thisptr.dimension()
+
     def set_dimension(self, dim):
         self.thisptr.set_dimension(<int>dim)
+
     def find(self, simplex):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
+            complex.push_back(i)
         return self.thisptr.find_simplex(complex)
-    def insert(self, simplex, filtration = 0.0):
+
+    def insert(self, simplex, filtration=0.0):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration)
+            complex.push_back(i)
+        return self.thisptr.insert_simplex_and_subfaces(complex,
+                                                        <double>filtration)
+
     def get_filtered_tree(self):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree()
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_filtered_tree()
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_skeleton_tree(self, dim):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_skeleton_tree(<int>dim)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_star_tree(self, simplex):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex)
+            complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_star_tree(complex)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_coface_tree(self, simplex, dim):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim)
+            complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_coface_tree(complex, <int>dim)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def remove_maximal_simplex(self, simplex):
         self.thisptr.remove_maximal_simplex(simplex)
-    def plain_homology(self, homology_coeff_field):
-        cdef Mini_simplex_tree_persistence_interface *pcohptr = new Mini_simplex_tree_persistence_interface(self.thisptr)
+
+    def plain_homology(self, homology_coeff_field=11):
+        cdef Mini_simplex_tree_persistence_interface * pcohptr \
+            = new Mini_simplex_tree_persistence_interface(self.thisptr)
         if pcohptr != NULL:
             pcohptr.get_persistence(homology_coeff_field, 0)
             del pcohptr
diff --git a/src/cython/src/cython/Rips_complex.pyx b/src/cython/src/cython/Rips_complex.pyx
index e722e483..3ca890d9 100644
--- a/src/cython/src/cython/Rips_complex.pyx
+++ b/src/cython/src/cython/Rips_complex.pyx
@@ -1,3 +1,7 @@
+from cython cimport numeric
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+
 """This file is part of the Gudhi Library. The Gudhi library
    (Geometric Understanding in Higher Dimensions) is a generic C++
    library for computational topology.
@@ -17,19 +21,17 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>."""
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
 
-__author__      = "Vincent Rouvreau"
-__copyright__   = "Copyright (C) 2016  INRIA Saclay (France)"
-__license__     = "GPL v3"
-
-from cython cimport numeric
-from libcpp.vector cimport vector
-from libcpp.utility cimport pair
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016  INRIA Saclay (France)"
+__license__ = "GPL v3"
 
 cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
     cdef cppclass Simplex_tree_options_full_featured:
         pass
+
     cdef cppclass Rips_complex_interface "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>":
         Simplex_tree()
         double filtration()
@@ -41,102 +43,131 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         void set_dimension(int dimension)
         int dimension()
         bint find_simplex(vector[int] simplex)
-        bint insert_simplex_and_subfaces(vector[int] simplex, double filtration)
+        bint insert_simplex_and_subfaces(vector[int] simplex,
+                                         double filtration)
         vector[pair[vector[int], double]] get_filtered_tree()
         vector[pair[vector[int], double]] get_skeleton_tree(int dimension)
         vector[pair[vector[int], double]] get_star_tree(vector[int] simplex)
-        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension)
+        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex,
+                                                          int dimension)
         void remove_maximal_simplex(vector[int] simplex)
-        void graph_expansion(vector[vector[double]] points,int max_dimension,double max_edge_length)
+        void graph_expansion(vector[vector[double]] points, int max_dimension,
+                             double max_edge_length)
 
 cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi":
     cdef cppclass Rips_complex_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>":
-        Rips_complex_persistence_interface(Rips_complex_interface* st)
+        Rips_complex_persistence_interface(Rips_complex_interface * st)
         void get_persistence(int homology_coeff_field, double min_persistence)
 
 # RipsComplex python interface
 cdef class RipsComplex:
-    cdef Rips_complex_interface *thisptr
-    def __cinit__(self, points=None, max_dimension=3, max_edge_length=float('inf')):
+    cdef Rips_complex_interface * thisptr
+
+    def __cinit__(self, points=None, max_dimension=3,
+                  max_edge_length=float('inf')):
         self.thisptr = new Rips_complex_interface()
         # Constructor from graph expansion
         if points is not None:
-            self.thisptr.graph_expansion(points,max_dimension,max_edge_length)
+            self.thisptr.graph_expansion(points, max_dimension,
+                                         max_edge_length)
+
     def __dealloc__(self):
         if self.thisptr != NULL:
             del self.thisptr
+
     def get_filtration(self):
         return self.thisptr.filtration()
+
     def filtration(self, simplex):
         return self.thisptr.simplex_filtration(simplex)
+
     def set_filtration(self, filtration):
-        self.thisptr.set_filtration(<double>filtration)
+        self.thisptr.set_filtration(<double> filtration)
+
     def initialize_filtration(self):
         self.thisptr.initialize_filtration()
+
     def num_vertices(self):
         return self.thisptr.num_vertices()
+
     def num_simplices(self):
         return self.thisptr.num_simplices()
+
     def dimension(self):
         return self.thisptr.dimension()
+
     def set_dimension(self, dim):
         self.thisptr.set_dimension(<int>dim)
+
     def find(self, simplex):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
+            complex.push_back(i)
         return self.thisptr.find_simplex(complex)
-    def insert(self, simplex, filtration = 0.0):
+
+    def insert(self, simplex, filtration=0.0):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration)
+            complex.push_back(i)
+        return self.thisptr.insert_simplex_and_subfaces(complex,
+                                                        <double>filtration)
+
     def get_filtered_tree(self):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree()
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_filtered_tree()
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_skeleton_tree(self, dim):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_skeleton_tree(<int>dim)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_star_tree(self, simplex):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex)
+            complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_star_tree(complex)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_coface_tree(self, simplex, dim):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim)
+            complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_coface_tree(complex, <int>dim)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def remove_maximal_simplex(self, simplex):
         self.thisptr.remove_maximal_simplex(simplex)
-    def persistence(self, homology_coeff_field, min_persistence = 0):
-        cdef Rips_complex_persistence_interface *pcohptr = new Rips_complex_persistence_interface(self.thisptr)
+
+    def persistence(self, homology_coeff_field=11, min_persistence=0):
+        cdef Rips_complex_persistence_interface * pcohptr \
+            = new Rips_complex_persistence_interface(self.thisptr)
         if pcohptr != NULL:
             pcohptr.get_persistence(homology_coeff_field, min_persistence)
             del pcohptr
diff --git a/src/cython/src/cython/Simplex_tree.pyx b/src/cython/src/cython/Simplex_tree.pyx
index 1543f792..e3cdc27b 100644
--- a/src/cython/src/cython/Simplex_tree.pyx
+++ b/src/cython/src/cython/Simplex_tree.pyx
@@ -1,3 +1,7 @@
+from cython cimport numeric
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+
 """This file is part of the Gudhi Library. The Gudhi library
    (Geometric Understanding in Higher Dimensions) is a generic C++
    library for computational topology.
@@ -17,19 +21,17 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>."""
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
 
-__author__      = "Vincent Rouvreau"
-__copyright__   = "Copyright (C) 2016  INRIA Saclay (France)"
-__license__     = "GPL v3"
-
-from cython cimport numeric
-from libcpp.vector cimport vector
-from libcpp.utility cimport pair
+__author__ = "Vincent Rouvreau"
+__copyright__ = "Copyright (C) 2016  INRIA Saclay (France)"
+__license__ = "GPL v3"
 
 cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
     cdef cppclass Simplex_tree_options_full_featured:
         pass
+
     cdef cppclass Simplex_tree_interface_full_featured "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>":
         Simplex_tree()
         double filtration()
@@ -41,98 +43,124 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         void set_dimension(int dimension)
         int dimension()
         bint find_simplex(vector[int] simplex)
-        bint insert_simplex_and_subfaces(vector[int] simplex, double filtration)
+        bint insert_simplex_and_subfaces(vector[int] simplex,
+                                         double filtration)
         vector[pair[vector[int], double]] get_filtered_tree()
         vector[pair[vector[int], double]] get_skeleton_tree(int dimension)
         vector[pair[vector[int], double]] get_star_tree(vector[int] simplex)
-        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension)
+        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex,
+                                                          int dimension)
         void remove_maximal_simplex(vector[int] simplex)
 
 cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi":
     cdef cppclass Simplex_tree_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>":
-        Simplex_tree_persistence_interface(Simplex_tree_interface_full_featured* st)
+        Simplex_tree_persistence_interface(Simplex_tree_interface_full_featured * st)
         void get_persistence(int homology_coeff_field, double min_persistence)
 
 # SimplexTree python interface
 cdef class SimplexTree:
-    cdef Simplex_tree_interface_full_featured *thisptr
+    cdef Simplex_tree_interface_full_featured * thisptr
+
     def __cinit__(self):
         self.thisptr = new Simplex_tree_interface_full_featured()
+
     def __dealloc__(self):
         if self.thisptr != NULL:
             del self.thisptr
+
     def get_filtration(self):
         return self.thisptr.filtration()
+
     def filtration(self, simplex):
         return self.thisptr.simplex_filtration(simplex)
+
     def set_filtration(self, filtration):
-        self.thisptr.set_filtration(<double>filtration)
+        self.thisptr.set_filtration(<double> filtration)
+
     def initialize_filtration(self):
         self.thisptr.initialize_filtration()
+
     def num_vertices(self):
         return self.thisptr.num_vertices()
+
     def num_simplices(self):
         return self.thisptr.num_simplices()
+
     def dimension(self):
         return self.thisptr.dimension()
+
     def set_dimension(self, dim):
         self.thisptr.set_dimension(<int>dim)
+
     def find(self, simplex):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
+            complex.push_back(i)
         return self.thisptr.find_simplex(complex)
-    def insert(self, simplex, filtration = 0.0):
+
+    def insert(self, simplex, filtration=0.0):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration)
+            complex.push_back(i)
+        return self.thisptr.insert_simplex_and_subfaces(complex,
+                                                        <double>filtration)
+
     def get_filtered_tree(self):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree()
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_filtered_tree()
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_skeleton_tree(self, dim):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_skeleton_tree(<int>dim)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_star_tree(self, simplex):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex)
+            complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_star_tree(complex)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def get_coface_tree(self, simplex, dim):
         cdef vector[int] complex
         for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim)
+            complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree \
+            = self.thisptr.get_coface_tree(complex, <int>dim)
         ct = []
         for filtered_complex in coface_tree:
             v = []
             for vertex in filtered_complex.first:
                 v.append(vertex)
-            ct.append((v,filtered_complex.second))
+            ct.append((v, filtered_complex.second))
         return ct
+
     def remove_maximal_simplex(self, simplex):
         self.thisptr.remove_maximal_simplex(simplex)
-    def persistence(self, homology_coeff_field, min_persistence = 0):
-        cdef Simplex_tree_persistence_interface *pcohptr = new Simplex_tree_persistence_interface(self.thisptr)
+
+    def persistence(self, homology_coeff_field=11, min_persistence=0):
+        cdef Simplex_tree_persistence_interface * pcohptr \
+            = new Simplex_tree_persistence_interface(self.thisptr)
         if pcohptr != NULL:
             pcohptr.get_persistence(homology_coeff_field, min_persistence)
             del pcohptr
diff --git a/src/cython/test/Alpha_complex_UT.py b/src/cython/test/Alpha_complex_UT.py
index 96331991..c14c43e2 100755
--- a/src/cython/test/Alpha_complex_UT.py
+++ b/src/cython/test/Alpha_complex_UT.py
@@ -2,43 +2,57 @@ import unittest
 
 import gudhi
 
-class TestAlphaComplex(unittest.TestCase):
-
-  def test_infinite_alpha(self):
-    point_list=[[0,0],[1,0],[0,1],[1,1]]
-    alpha_complex = gudhi.AlphaComplex(points=point_list)
-
-    self.assertEqual(alpha_complex.num_simplices(), 11)
-    self.assertEqual(alpha_complex.num_vertices(), 4)
-
-    self.assertEqual(alpha_complex.get_filtered_tree(), [([0], 0.0), ([1], 0.0), ([2], 0.0), ([3], 0.0), ([0, 1], 0.25), ([0, 2], 0.25), ([1, 3], 0.25), ([2, 3], 0.25), ([1, 2], 0.5), ([0, 1, 2], 0.5), ([1, 2, 3], 0.5)])
-    self.assertEqual(alpha_complex.get_star_tree([0]), [([0], 0.0), ([0, 1], 0.25), ([0, 1, 2], 0.5), ([0, 2], 0.25)])
-    self.assertEqual(alpha_complex.get_coface_tree([0], 1), [([0, 1], 0.25), ([0, 2], 0.25)])
 
-    self.assertEqual(point_list[0], alpha_complex.get_point(0))
-    self.assertEqual(point_list[1], alpha_complex.get_point(1))
-    self.assertEqual(point_list[2], alpha_complex.get_point(2))
-    self.assertEqual(point_list[3], alpha_complex.get_point(3))
-    self.assertEqual([], alpha_complex.get_point(4))
-    self.assertEqual([], alpha_complex.get_point(125))
-
-  def test_filtered_alpha(self):
-    point_list=[[0,0],[1,0],[0,1],[1,1]]
-    filtered_alpha = gudhi.AlphaComplex(points=point_list,max_alpha_square=0.25)
-
-    self.assertEqual(filtered_alpha.num_simplices(), 8)
-    self.assertEqual(filtered_alpha.num_vertices(), 4)
-
-    self.assertEqual(point_list[0], filtered_alpha.get_point(0))
-    self.assertEqual(point_list[1], filtered_alpha.get_point(1))
-    self.assertEqual(point_list[2], filtered_alpha.get_point(2))
-    self.assertEqual(point_list[3], filtered_alpha.get_point(3))
-    self.assertEqual([], filtered_alpha.get_point(4))
-    self.assertEqual([], filtered_alpha.get_point(125))
+class TestAlphaComplex(unittest.TestCase):
 
-    self.assertEqual(filtered_alpha.get_filtered_tree(), [([0], 0.0), ([1], 0.0), ([2], 0.0), ([3], 0.0), ([0, 1], 0.25), ([0, 2], 0.25), ([1, 3], 0.25), ([2, 3], 0.25)])
-    self.assertEqual(filtered_alpha.get_star_tree([0]), [([0], 0.0), ([0, 1], 0.25), ([0, 2], 0.25)])
-    self.assertEqual(filtered_alpha.get_coface_tree([0], 1), [([0, 1], 0.25), ([0, 2], 0.25)])
+    def test_infinite_alpha(self):
+        point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+        alpha_complex = gudhi.AlphaComplex(points=point_list)
+
+        self.assertEqual(alpha_complex.num_simplices(), 11)
+        self.assertEqual(alpha_complex.num_vertices(), 4)
+
+        self.assertEqual(alpha_complex.get_filtered_tree(),
+                         [([0], 0.0), ([1], 0.0), ([2], 0.0), ([3], 0.0),
+                          ([0, 1], 0.25), ([0, 2], 0.25), ([1, 3], 0.25),
+                          ([2, 3], 0.25), ([1, 2], 0.5), ([0, 1, 2], 0.5),
+                          ([1, 2, 3], 0.5)])
+        self.assertEqual(alpha_complex.get_star_tree([0]),
+                         [([0], 0.0), ([0, 1], 0.25), ([0, 1, 2], 0.5),
+                         ([0, 2], 0.25)])
+        self.assertEqual(alpha_complex.get_coface_tree([0], 1),
+                         [([0, 1], 0.25), ([0, 2], 0.25)])
+
+        self.assertEqual(point_list[0], alpha_complex.get_point(0))
+        self.assertEqual(point_list[1], alpha_complex.get_point(1))
+        self.assertEqual(point_list[2], alpha_complex.get_point(2))
+        self.assertEqual(point_list[3], alpha_complex.get_point(3))
+        self.assertEqual([], alpha_complex.get_point(4))
+        self.assertEqual([], alpha_complex.get_point(125))
+
+    def test_filtered_alpha(self):
+        point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+        filtered_alpha = gudhi.AlphaComplex(points=point_list,
+                                            max_alpha_square=0.25)
+
+        self.assertEqual(filtered_alpha.num_simplices(), 8)
+        self.assertEqual(filtered_alpha.num_vertices(), 4)
+
+        self.assertEqual(point_list[0], filtered_alpha.get_point(0))
+        self.assertEqual(point_list[1], filtered_alpha.get_point(1))
+        self.assertEqual(point_list[2], filtered_alpha.get_point(2))
+        self.assertEqual(point_list[3], filtered_alpha.get_point(3))
+        self.assertEqual([], filtered_alpha.get_point(4))
+        self.assertEqual([], filtered_alpha.get_point(125))
+
+        self.assertEqual(filtered_alpha.get_filtered_tree(),
+                         [([0], 0.0), ([1], 0.0), ([2], 0.0), ([3], 0.0),
+                          ([0, 1], 0.25), ([0, 2], 0.25), ([1, 3], 0.25),
+                          ([2, 3], 0.25)])
+        self.assertEqual(filtered_alpha.get_star_tree([0]),
+                         [([0], 0.0), ([0, 1], 0.25), ([0, 2], 0.25)])
+        self.assertEqual(filtered_alpha.get_coface_tree([0], 1),
+                         [([0, 1], 0.25), ([0, 2], 0.25)])
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/src/cython/test/Mini_simplex_tree_UT.py b/src/cython/test/Mini_simplex_tree_UT.py
index 0d2ce3c3..8f2f56df 100755
--- a/src/cython/test/Mini_simplex_tree_UT.py
+++ b/src/cython/test/Mini_simplex_tree_UT.py
@@ -2,26 +2,28 @@ import unittest
 
 import gudhi
 
+
 class TestMiniSimplexTree(unittest.TestCase):
 
-  def test_mini(self):
-    triangle012 = [0,1,2]
-    edge03 = [0,3]
-    mini_st = gudhi.MiniSimplexTree()
-    self.assertTrue(mini_st.insert(triangle012))
-    self.assertTrue(mini_st.insert(edge03))
-    # FIXME: Remove this line
-    mini_st.set_dimension(2);
+    def test_mini(self):
+        triangle012 = [0, 1, 2]
+        edge03 = [0, 3]
+        mini_st = gudhi.MiniSimplexTree()
+        self.assertTrue(mini_st.insert(triangle012))
+        self.assertTrue(mini_st.insert(edge03))
+        # FIXME: Remove this line
+        mini_st.set_dimension(2)
 
-    edge02 = [0,2]
-    self.assertTrue(mini_st.find(edge02))
-    self.assertEqual(mini_st.get_coface_tree(edge02, 1), [([0, 1, 2], 0.0)])
+        edge02 = [0, 2]
+        self.assertTrue(mini_st.find(edge02))
+        self.assertEqual(mini_st.get_coface_tree(edge02, 1),
+                         [([0, 1, 2], 0.0)])
 
-    # remove_maximal_simplex test
-    self.assertEqual(mini_st.get_coface_tree(triangle012, 1), [])
-    mini_st.remove_maximal_simplex(triangle012)
-    self.assertTrue(mini_st.find(edge02))
-    self.assertFalse(mini_st.find(triangle012))
+        # remove_maximal_simplex test
+        self.assertEqual(mini_st.get_coface_tree(triangle012, 1), [])
+        mini_st.remove_maximal_simplex(triangle012)
+        self.assertTrue(mini_st.find(edge02))
+        self.assertFalse(mini_st.find(triangle012))
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/src/cython/test/Rips_complex_UT.py b/src/cython/test/Rips_complex_UT.py
index d27e180c..ccff5c2d 100755
--- a/src/cython/test/Rips_complex_UT.py
+++ b/src/cython/test/Rips_complex_UT.py
@@ -2,23 +2,34 @@ import unittest
 
 import gudhi
 
+
 class TestRipsComplex(unittest.TestCase):
 
-  def test_rips(self):
-    point_list=[[0,0],[1,0],[0,1],[1,1]]
-    rips_complex = gudhi.RipsComplex(points=point_list,max_dimension=1,max_edge_length=42)
+    def test_rips(self):
+        point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+        rips_complex = gudhi.RipsComplex(points=point_list, max_dimension=1,
+                                         max_edge_length=42)
 
-    self.assertEqual(rips_complex.num_simplices(), 10)
-    self.assertEqual(rips_complex.num_vertices(), 4)
+        self.assertEqual(rips_complex.num_simplices(), 10)
+        self.assertEqual(rips_complex.num_vertices(), 4)
 
-    self.assertEqual(rips_complex.get_filtered_tree(), [([0], 0.0), ([1], 0.0), ([2], 0.0), ([3], 0.0), ([0, 1], 1.0), ([0, 2], 1.0), ([1, 3], 1.0), ([2, 3], 1.0), ([1, 2], 1.4142135623730951), ([0, 3], 1.4142135623730951)])
-    self.assertEqual(rips_complex.get_star_tree([0]), [([0], 0.0), ([0, 1], 1.0), ([0, 2], 1.0), ([0, 3], 1.4142135623730951)])
-    self.assertEqual(rips_complex.get_coface_tree([0], 1), [([0, 1], 1.0), ([0, 2], 1.0), ([0, 3], 1.4142135623730951)])
+        self.assertEqual(rips_complex.get_filtered_tree(),
+                         [([0], 0.0), ([1], 0.0), ([2], 0.0), ([3], 0.0),
+                          ([0, 1], 1.0), ([0, 2], 1.0), ([1, 3], 1.0),
+                          ([2, 3], 1.0), ([1, 2], 1.4142135623730951),
+                          ([0, 3], 1.4142135623730951)])
+        self.assertEqual(rips_complex.get_star_tree([0]),
+                         [([0], 0.0), ([0, 1], 1.0), ([0, 2], 1.0),
+                          ([0, 3], 1.4142135623730951)])
+        self.assertEqual(rips_complex.get_coface_tree([0], 1),
+                         [([0, 1], 1.0), ([0, 2], 1.0),
+                          ([0, 3], 1.4142135623730951)])
 
-    filtered_rips = gudhi.RipsComplex(points=point_list,max_dimension=1,max_edge_length=1.0)
+        filtered_rips = gudhi.RipsComplex(points=point_list, max_dimension=1,
+                                          max_edge_length=1.0)
 
-    self.assertEqual(filtered_rips.num_simplices(), 8)
-    self.assertEqual(filtered_rips.num_vertices(), 4)
+        self.assertEqual(filtered_rips.num_simplices(), 8)
+        self.assertEqual(filtered_rips.num_vertices(), 4)
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/src/cython/test/Simplex_tree_UT.py b/src/cython/test/Simplex_tree_UT.py
index b3ded581..392c6d71 100755
--- a/src/cython/test/Simplex_tree_UT.py
+++ b/src/cython/test/Simplex_tree_UT.py
@@ -2,56 +2,64 @@ import unittest
 
 import gudhi
 
+
 class TestSimplexTree(unittest.TestCase):
 
-  def test_insertion(self):
-    st = gudhi.SimplexTree()
-
-    # insert test
-    self.assertTrue(st.insert([0,1]))
-    self.assertTrue(st.insert([0,1,2], filtration=4.0))
-    self.assertEqual(st.num_simplices(), 7)
-    self.assertEqual(st.num_vertices(), 3)
-
-    # find test
-    self.assertTrue(st.find([0,1,2]))
-    self.assertTrue(st.find([0,1]))
-    self.assertTrue(st.find([0,2]))
-    self.assertTrue(st.find([0]))
-    self.assertTrue(st.find([1]))
-    self.assertTrue(st.find([2]))
-    self.assertFalse(st.find([3]))
-    self.assertFalse(st.find([0,3]))
-    self.assertFalse(st.find([1,3]))
-    self.assertFalse(st.find([2,3]))
-
-    # filtration test
-    st.set_filtration(5.0)
-    st.initialize_filtration()
-    self.assertEqual(st.get_filtration(), 5.0)
-    self.assertEqual(st.filtration([0,1,2]), 4.0)
-    self.assertEqual(st.filtration([0,2]), 4.0)
-    self.assertEqual(st.filtration([1,2]), 4.0)
-    self.assertEqual(st.filtration([2]), 4.0)
-    self.assertEqual(st.filtration([0,1]), 0.0)
-    self.assertEqual(st.filtration([0]), 0.0)
-    self.assertEqual(st.filtration([1]), 0.0)
-      
-    # skeleton_tree test
-    self.assertEqual(st.get_skeleton_tree(2), [([0, 1, 2], 4.0), ([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0), ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)])
-    self.assertEqual(st.get_skeleton_tree(1), [([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0), ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)])
-    self.assertEqual(st.get_skeleton_tree(0), [([0], 0.0), ([1], 0.0), ([2], 4.0)])
-
-    # remove_maximal_simplex test
-    self.assertEqual(st.get_coface_tree([0,1,2], 1), [])
-    st.remove_maximal_simplex([0,1,2])
-    self.assertEqual(st.get_skeleton_tree(2), [([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0), ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)])
-    self.assertFalse(st.find([0,1,2]))
-    self.assertTrue(st.find([0,1]))
-    self.assertTrue(st.find([0,2]))
-    self.assertTrue(st.find([0]))
-    self.assertTrue(st.find([1]))
-    self.assertTrue(st.find([2]))
+    def test_insertion(self):
+        st = gudhi.SimplexTree()
+
+        # insert test
+        self.assertTrue(st.insert([0, 1]))
+        self.assertTrue(st.insert([0, 1, 2], filtration=4.0))
+        self.assertEqual(st.num_simplices(), 7)
+        self.assertEqual(st.num_vertices(), 3)
+
+        # find test
+        self.assertTrue(st.find([0, 1, 2]))
+        self.assertTrue(st.find([0, 1]))
+        self.assertTrue(st.find([0, 2]))
+        self.assertTrue(st.find([0]))
+        self.assertTrue(st.find([1]))
+        self.assertTrue(st.find([2]))
+        self.assertFalse(st.find([3]))
+        self.assertFalse(st.find([0, 3]))
+        self.assertFalse(st.find([1, 3]))
+        self.assertFalse(st.find([2, 3]))
+
+        # filtration test
+        st.set_filtration(5.0)
+        st.initialize_filtration()
+        self.assertEqual(st.get_filtration(), 5.0)
+        self.assertEqual(st.filtration([0, 1, 2]), 4.0)
+        self.assertEqual(st.filtration([0, 2]), 4.0)
+        self.assertEqual(st.filtration([1, 2]), 4.0)
+        self.assertEqual(st.filtration([2]), 4.0)
+        self.assertEqual(st.filtration([0, 1]), 0.0)
+        self.assertEqual(st.filtration([0]), 0.0)
+        self.assertEqual(st.filtration([1]), 0.0)
+
+        # skeleton_tree test
+        self.assertEqual(st.get_skeleton_tree(2),
+                         [([0, 1, 2], 4.0), ([0, 1], 0.0), ([0, 2], 4.0),
+                          ([0], 0.0), ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)])
+        self.assertEqual(st.get_skeleton_tree(1),
+                         [([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0),
+                          ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)])
+        self.assertEqual(st.get_skeleton_tree(0),
+                         [([0], 0.0), ([1], 0.0), ([2], 4.0)])
+
+        # remove_maximal_simplex test
+        self.assertEqual(st.get_coface_tree([0, 1, 2], 1), [])
+        st.remove_maximal_simplex([0, 1, 2])
+        self.assertEqual(st.get_skeleton_tree(2),
+                         [([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0),
+                          ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)])
+        self.assertFalse(st.find([0, 1, 2]))
+        self.assertTrue(st.find([0, 1]))
+        self.assertTrue(st.find([0, 2]))
+        self.assertTrue(st.find([0]))
+        self.assertTrue(st.find([1]))
+        self.assertTrue(st.find([2]))
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()