pep8 cleanup for structure/

Author: fchapoton

src/sage/structure/__init__.py

@@ -1,3 +1,3 @@
 # sage_setup: distribution = sagemath-objects
 # Resolve a cyclic import
-import sage.structure.element
+import sage.structure.element

src/sage/structure/all.py

@@ -21,10 +21,10 @@
 
 from sage.structure.proof import all as proof
 
-from sage.misc.lazy_import import lazy_import
-lazy_import('sage.structure.formal_sum', ['FormalSums', 'FormalSum'])
-del lazy_import
-
 from sage.structure.mutability import Mutability
 
 from sage.structure.element_wrapper import ElementWrapper
+
+from sage.misc.lazy_import import lazy_import
+lazy_import('sage.structure.formal_sum', ['FormalSums', 'FormalSum'])
+del lazy_import

src/sage/structure/formal_sum.py

@@ -65,11 +65,11 @@
 #
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
-
-from sage.misc.repr import repr_lincomb
 import operator
 from collections import OrderedDict
 
+from sage.misc.persist import register_unpickle_override
+from sage.misc.repr import repr_lincomb
 from sage.modules.module import Module
 from sage.structure.element import ModuleElement
 from sage.structure.richcmp import richcmp
@@ -392,11 +392,14 @@ def _element_constructor_(self, x, check=True, reduce=True):
             else:
                 x = x._data
         if isinstance(x, list):
-            return self.element_class(x, check=check,reduce=reduce,parent=self)
+            return self.element_class(x, check=check,
+                                      reduce=reduce, parent=self)
         if x == 0:
-            return self.element_class([], check=False, reduce=False, parent=self)
+            return self.element_class([], check=False,
+                                      reduce=False, parent=self)
         else:
-            return self.element_class([(self.base_ring()(1), x)], check=False, reduce=False, parent=self)
+            return self.element_class([(self.base_ring()(1), x)],
+                                      check=False, reduce=False, parent=self)
 
     def _coerce_map_from_(self, X):
         r"""
@@ -413,7 +416,7 @@ def _coerce_map_from_(self, X):
               From: Abelian Group of all Formal Finite Sums over Integer Ring
               To:   Abelian Group of all Formal Finite Sums over Rational Field
         """
-        if isinstance(X,FormalSums):
+        if isinstance(X, FormalSums):
             if self.base_ring().has_coerce_map_from(X.base_ring()):
                 return True
         return False
@@ -475,13 +478,12 @@ def _an_element_(self, check=False, reduce=False):
             1/2
         """
         return self.element_class([(self.base_ring().an_element(), 1)],
-                         check=check, reduce=reduce, parent=self)
+                                  check=check, reduce=reduce, parent=self)
 
 
 formal_sums = FormalSums()
 
 # Formal sums now derives from UniqueRepresentation, which makes the
 # factory function unnecessary. This is why the name was changed from
 # class FormalSums_generic to class FormalSums.
-from sage.misc.persist import register_unpickle_override
 register_unpickle_override('sage.structure.formal_sum', 'FormalSums_generic', FormalSums)

src/sage/structure/gens_py.py

@@ -3,7 +3,7 @@
 Pure python code for abstract base class for objects with generators
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2005 William Stein <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -15,8 +15,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 
 def multiplicative_iterator(M):

src/sage/structure/indexed_generators.py

@@ -316,7 +316,7 @@ def _parse_names(self, m, use_latex):
                     return names[m]
                 except KeyError:
                     return None
-            else: # treat it like a list
+            else:  # treat it like a list
                 try:
                     i = self._indices.rank(m)
                 except (AttributeError, TypeError, KeyError, ValueError):
@@ -458,7 +458,7 @@ def _repr_generator(self, m):
                 return self.prefix() + left + (', '.join(repr(val) for val in m)) + right
         if not quotes and isinstance(m, str):
             return self.prefix() + left + m + right
-        return self.prefix() + left + repr(m) + right # mind the (m), to accept a tuple for m
+        return self.prefix() + left + repr(m) + right  # mind the (m), to accept a tuple for m
 
     def _ascii_art_generator(self, m):
         r"""

src/sage/structure/list_clone_timings.py

@@ -73,12 +73,12 @@
     cy_add1_mutable(e)                   :  625 loops, best of 3: 14.1 µs per loop
     cy_add1_with(e)                      :  625 loops, best of 3: 17.5 µs per loop
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2009-2010 Florent Hivert <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.structure.list_clone import ClonableArray
 from sage.structure.list_clone_demo import IncreasingArrays
@@ -116,7 +116,7 @@ def check(self):
 
 
 #####################################################################
-######                    Timings functions                    ######
+#                         Timings functions                         #
 #####################################################################
 def add1_internal(bla):
     """

src/sage/structure/proof/all.py

@@ -1,4 +1,5 @@
 # sage_setup: distribution = sagemath-objects
+from sage.structure.proof.proof import WithProof
 
 
 def arithmetic(t=None):
@@ -240,6 +241,3 @@ def all(t=None):
         return _proof_prefs._require_proof.copy()
     for s in _proof_prefs._require_proof:
         _proof_prefs._require_proof[s] = bool(t)
-
-
-from sage.structure.proof.proof import WithProof

src/sage/structure/proof/proof.py

@@ -225,7 +225,8 @@ def get_flag(t=None, subsystem=None):
         False
     """
     if t is None:
-        if subsystem in ["arithmetic", "elliptic_curve", "linear_algebra", "number_field","polynomial"]:
+        if subsystem in ["arithmetic", "elliptic_curve",
+                         "linear_algebra", "number_field", "polynomial"]:
             return _proof_prefs._require_proof[subsystem]
         else:
             return _proof_prefs._require_proof["other"]

src/sage/structure/sequence.py

@@ -70,7 +70,7 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-
+from sage.misc.persist import register_unpickle_override
 import sage.structure.sage_object
 import sage.structure.coerce
 
@@ -239,7 +239,7 @@ def Sequence(x, universe=None, check=True, immutable=False, cr=False, cr_str=Non
             # start the pairwise coercion
             for i in range(len(x) - 1):
                 try:
-                    x[i], x[i+1] = sage.structure.element.canonical_coercion(x[i],x[i+1])
+                    x[i], x[i+1] = sage.structure.element.canonical_coercion(x[i], x[i+1])
                 except TypeError:
                     from sage.categories.objects import Objects
                     universe = Objects()
@@ -515,16 +515,16 @@ def __getitem__(self, n):
                             check=False,
                             immutable=False,
                             cr=self.__cr)
-        else:
-            return list.__getitem__(self,n)
+
+        return list.__getitem__(self, n)
 
     # We have to define the *slice functions as long as Sage uses Python 2.*
     # otherwise the inherited *slice functions from list are called
     def __getslice__(self, i, j):
-        return self.__getitem__(slice(i,j))
+        return self.__getitem__(slice(i, j))
 
     def __setslice__(self, i, j, value):
-        return self.__setitem__(slice(i,j), value)
+        return self.__setitem__(slice(i, j), value)
 
     def append(self, x):
         """
@@ -863,19 +863,19 @@ def __getattr__(self, name):
             sage: hash(S)
             34
         """
-        if name == "_Sequence_generic__cr" and hasattr(self,"_Sequence__cr"):
+        if name == "_Sequence_generic__cr" and hasattr(self, "_Sequence__cr"):
             self.__cr = self._Sequence__cr
             return self.__cr
-        elif name == "_Sequence_generic__cr_str" and hasattr(self,"_Sequence__cr_str"):
+        elif name == "_Sequence_generic__cr_str" and hasattr(self, "_Sequence__cr_str"):
             self.__cr_str = self._Sequence__cr_str
             return self.__cr_str
-        elif name == "_Sequence_generic__immutable" and hasattr(self,"_Sequence__immutable"):
+        elif name == "_Sequence_generic__immutable" and hasattr(self, "_Sequence__immutable"):
             self.__immutable = self._Sequence__immutable
             return self.__immutable
-        elif name == "_Sequence_generic__universe" and hasattr(self,"_Sequence__universe"):
+        elif name == "_Sequence_generic__universe" and hasattr(self, "_Sequence__universe"):
             self.__universe = self._Sequence__universe
             return self.__universe
-        elif name == "_Sequence_generic__hash" and hasattr(self,"_Sequence__hash"):
+        elif name == "_Sequence_generic__hash" and hasattr(self, "_Sequence__hash"):
             self.__hash = self._Sequence__hash
             return self.__hash
         else:
@@ -884,5 +884,4 @@ def __getattr__(self, name):
 
 seq = Sequence
 
-from sage.misc.persist import register_unpickle_override
 register_unpickle_override('sage.structure.sequence', 'Sequence', Sequence_generic)

src/sage/structure/set_factories.py

@@ -306,12 +306,12 @@
 
 - Florent Hivert (2011-2012): initial revision
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2012 Florent Hivert <florent.hivert at lri.fr>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 
 from sage.structure.sage_object import SageObject
@@ -846,7 +846,8 @@ def element_constructor_attributes(self, constraints):
             sage: pol.element_constructor_attributes(())
             {'_element_constructor_': <... 'tuple'>, '_parent_for': None}
         """
-        return {'_element_constructor_' : self._constructor, '_parent_for' : None}
+        return {'_element_constructor_': self._constructor,
+                '_parent_for': None}
 
     def _repr_(self):
         r"""
@@ -1107,7 +1108,7 @@ def __contains__(self, x):
             False
         """
         if (isinstance(x, self.element_class) and
-            x.parent() == self._parent_for):  # TODO: is_parent_of ???
+                x.parent() == self._parent_for):  # TODO: is_parent_of ???
             try:
                 self.check_element(x, True)
             except ValueError:
@@ -1140,7 +1141,7 @@ def __call__(self, *args, **keywords):
         # Ensure idempotence of element construction
         if (len(args) == 1 and
             isinstance(args[0], self.element_class) and
-            args[0].parent() == self._parent_for):
+                args[0].parent() == self._parent_for):
             check = keywords.get("check", True)
             if check:
                 self.check_element(args[0], check)