Trac #34910: autopep8 for E3 in combinat/

except in the designs/ and matrices/ subfolders of combinat

done using {{{autopep8 -i --select=E3 *.py}}}

URL: https://trac.sagemath.org/34910
Reported by: chapoton
Ticket author(s): Frédéric Chapoton
Reviewer(s): Matthias Koeppe

Author: Release Manager

src/sage/combinat/abstract_tree.py

@@ -109,6 +109,7 @@ class AbstractTree():
         sage: TestSuite(OrderedTree()).run()
         sage: TestSuite(BinaryTree()).run()
     """
+
     def pre_order_traversal_iter(self):
         r"""
         The depth-first pre-order traversal iterator.
@@ -1828,6 +1829,7 @@ class or one of its subclasses generally, at least :class:`ClonableArray
 
     See also the assumptions in :class:`AbstractTree`.
     """
+
     def check(self):
         """
         Check that ``self`` is a correct tree.
@@ -2044,6 +2046,7 @@ class AbstractLabelledTree(AbstractTree):
 
     .. SEEALSO:: :class:`AbstractTree`
     """
+
     def __init__(self, parent, children, label=None, check=True):
         """
         TESTS::
@@ -2321,6 +2324,7 @@ class AbstractLabelledClonableTree(AbstractLabelledTree,
        here from :class:`~sage.structure.list_clone.ClonableArray`, because it would prevent us to
        inherit later from :class:`~sage.structure.list_clone.ClonableList`.
     """
+
     def set_root_label(self, label):
         """
         Set the label of the root of ``self``.

src/sage/combinat/affine_permutation.py

@@ -42,6 +42,7 @@ class AffinePermutation(ClonableArray):
         sage: p
         Type A affine permutation with window [3, -1, 0, 6, 5, 4, 10, 9]
     """
+
     def __init__(self, parent, lst, check=True):
         r"""
         Initialize ``self``
@@ -407,7 +408,6 @@ def grassmannian_quotient(self, i=0, side='right'):
             return (fin, gr)
 
 
-
 class AffinePermutationTypeA(AffinePermutation):
     #----------------------
     #Type-specific methods.
@@ -448,7 +448,6 @@ def check(self):
         if l != list(range(k+1)):
             raise ValueError("entries must have distinct residues")
 
-
     def value(self, i, base_window=False):
         r"""
         Return the image of the integer ``i`` under this permutation.
@@ -730,7 +729,6 @@ def maximal_cyclic_factor(self, typ='decreasing', side='right', verbose=False):
             best_T.reverse()
         return best_T
 
-
     def maximal_cyclic_decomposition(self, typ='decreasing', side='right', verbose=False):
         r"""
         Find the unique maximal decomposition of ``self`` into cyclically
@@ -1065,6 +1063,8 @@ def tableau_of_word(self, w, typ='decreasing', side='right', alpha=None):
         return tab
 
 #-------------------------------------------------------------------------------
+
+
 class AffinePermutationTypeC(AffinePermutation):
     #----------------------
     #Type-specific methods.
@@ -1321,7 +1321,6 @@ def check(self):
             raise ValueError("type B affine permutations have an even number of "
                              "entries less than 0 to the right of the 0th position")
 
-
     def apply_simple_reflection_right(self, i):
         r"""
         Apply the simple reflection indexed by ``i`` on positions.
@@ -1843,8 +1842,6 @@ def to_type_a(self):
         return A(self)
 
 
-
-
 #-------------------------------------------------------------------------
 #    Class of all affine permutations.
 #-------------------------------------------------------------------------

src/sage/combinat/alternating_sign_matrix.py

@@ -1046,6 +1046,7 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
         sage: L.category()
         Category of facade finite enumerated lattice posets
     """
+
     def __init__(self, n):
         r"""
         Initialize ``self``.
@@ -1657,6 +1658,7 @@ class MonotoneTriangles(GelfandTsetlinPatternsTopRow):
         sage: all(A.from_monotone_triangle(m).to_monotone_triangle() == m for m in M)
         True
     """
+
     def __init__(self, n):
         r"""
         Initialize ``self``.

src/sage/combinat/backtrack.py

@@ -44,6 +44,7 @@ class GenericBacktracker():
     See also :class:`RecursivelyEnumeratedSet_forest` for
     handling simple special cases.
     """
+
     def __init__(self, initial_data, initial_state):
         r"""
         EXAMPLES::
@@ -127,6 +128,7 @@ class PositiveIntegerSemigroup(UniqueRepresentation, RecursivelyEnumeratedSet_fo
         sage: TestSuite(PP).run(skip='_test_enumerated_set_contains')
         sage: PP._test_enumerated_set_contains()  # long time
     """
+
     def __init__(self):
         r"""
         TESTS::

src/sage/combinat/baxter_permutations.py

@@ -70,6 +70,7 @@ class BaxterPermutations_size(BaxterPermutations):
         sage: BaxterPermutations_size(5)
         Baxter permutations of size 5
     """
+
     def __init__(self, n):
         """
         EXAMPLES::
@@ -252,6 +253,7 @@ class BaxterPermutations_all(DisjointUnionEnumeratedSets, BaxterPermutations):
         sage: BaxterPermutations_all()
         Baxter permutations
     """
+
     def __init__(self, n=None):
         r"""
         EXAMPLES::

src/sage/combinat/binary_recurrence_sequences.py

@@ -105,7 +105,6 @@ class BinaryRecurrenceSequence(SageObject):
     """
 
     def __init__(self, b, c, u0=0, u1=1):
-
         """
         See :class:`BinaryRecurrenceSequence` for full documentation.
 
@@ -830,7 +829,6 @@ def _goodness(n, R, p):
 
 
 def _next_good_prime(p, R, qq, patience, qqold):
-
     """
     Find the next prime `\\ell` which is good by ``qq`` but not by ``qqold``, 1 mod ``p``, and for which
     ``b^2+4*c`` is a square mod `\\ell`, for the sequence ``R`` if it is possible in runtime patience.
@@ -1033,7 +1031,6 @@ def _is_p_power_mod(a, p, N):
 
 
 def _estimated_time(M2, M1, length, p):
-
     """
     Find the estimated time to extend congruences mod M1 to consistent congruences mod M2.
 

src/sage/combinat/binary_tree.py

@@ -4179,6 +4179,7 @@ class BinaryTrees_size(BinaryTrees):
         sage: from sage.combinat.binary_tree import BinaryTrees_size
         sage: for i in range(6): TestSuite(BinaryTrees_size(i)).run()
     """
+
     def __init__(self, size):
         """
         TESTS::
@@ -4318,6 +4319,7 @@ class FullBinaryTrees_all(DisjointUnionEnumeratedSets, BinaryTrees):
     """
     All full binary trees.
     """
+
     def __init__(self):
         """
         TESTS::
@@ -4415,6 +4417,7 @@ class FullBinaryTrees_size(BinaryTrees):
     """
     Full binary trees of a fixed size (number of nodes).
     """
+
     def __init__(self, size):
         r"""
         TESTS::
@@ -5157,6 +5160,7 @@ class LabelledBinaryTrees(LabelledOrderedTrees):
     This is a parent stub to serve as a factory class for trees with various
     labels constraints.
     """
+
     def _repr_(self):
         """
         TESTS::

src/sage/combinat/blob_algebra.py

@@ -33,6 +33,8 @@
 from sage.combinat.dyck_word import DyckWords
 
 #@add_metaclass(InheritComparisonClasscallMetaclass)
+
+
 class BlobDiagram(Element):
     r"""
     A blob diagram.
@@ -45,6 +47,7 @@ class BlobDiagram(Element):
     those without. The blobed pairs must either be either the leftmost
     propagating strand or to the left of it and not nested.
     """
+
     def __init__(self, parent, marked, unmarked):
         r"""
         Initialize ``self``.
@@ -148,10 +151,12 @@ def temperley_lieb_diagram(self):
         """
         return self.parent()._TL_diagrams(self.marked + self.unmarked)
 
+
 class BlobDiagrams(Parent, UniqueRepresentation):
     r"""
     The set of all blob diagrams.
     """
+
     def __init__(self, n):
         r"""
         Initialize ``self``.
@@ -370,6 +375,7 @@ def __iter__(self):
 
     Element = BlobDiagram
 
+
 class BlobAlgebra(CombinatorialFreeModule):
     r"""
     The blob algebra.

src/sage/combinat/cartesian_product.py

@@ -74,6 +74,7 @@ class for ``cartesian_product``;
         sage: elt.parent() is c
         True
     """
+
     def __init__(self, *iters):
         """
         TESTS::

src/sage/combinat/cluster_algebra_quiver/cluster_seed.py

@@ -130,6 +130,7 @@ class ClusterSeed(SageObject):
         sage: S = ClusterSeed(['D', 4],user_labels = [-1, 0, 1, 2]);S
         A seed for a cluster algebra of rank 4 of type ['D', 4]
     """
+
     def __init__(self, data, frozen=None, is_principal=False, user_labels=None, user_labels_prefix='x'):
         r"""
 
@@ -3443,7 +3444,6 @@ def mutation_class_iter(self, depth=infinity, show_depth=False,
         else:
             yield self
 
-
         # instantiate the variables
         clusters = {}
         clusters[ cl ] = [ self, list(range(n)), [] ]
@@ -4628,6 +4628,7 @@ def coeff_recurs(p, q, a1, a2, b, c):
             return sum((-1)**(k-1)*coeff_recurs(p, q-k, a1, a2, b, c)*_bino(a1-b*p+k-1, k)
                        for k in range(1, q+1))
 
+
 def PathSubset(n, m):
     r"""
     Encodes a *maximal* Dyck path from (0,0) to (n,m) (for n >= m >= 0) as a subset of {0,1,2,..., 2n-1}.
@@ -4687,6 +4688,7 @@ def SetToPath(T):
         ans.append(2*n-2)
     return ans
 
+
 def is_LeeLiZel_allowable(T,n,m,b,c):
     """
     Check if the subset T contributes to the computation of the greedy