gh-35923: some pycodestyle fixes in sets/
    
<!-- ^^^^^
Please provide a concise, informative and self-explanatory title.
Don't put issue numbers in there, do this in the PR body below.
For example, instead of "Fixes #1234" use "Introduce new method to
calculate 1+1"
-->
<!-- Describe your changes here in detail -->

this fixes a few pycodestyle warnings in the `sets` folder

<!-- Why is this change required? What problem does it solve? -->
<!-- If this PR resolves an open issue, please link to it here. For
example "Fixes #12345". -->
<!-- If your change requires a documentation PR, please link it
appropriately. -->

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->
<!-- If your change requires a documentation PR, please link it
appropriately -->
<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
<!-- Feel free to remove irrelevant items. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #35923
Reported by: Frédéric Chapoton
Reviewer(s): David Coudert

Author: Release Manager

src/sage/sets/cartesian_product.py

@@ -28,6 +28,7 @@
 from sage.categories.rings import Rings
 _Rings = Rings()
 
+
 class CartesianProduct(UniqueRepresentation, Parent):
     """
     A class implementing a raw data structure for Cartesian products
@@ -79,7 +80,7 @@ def __init__(self, sets, category, flatten=False):
         self._sets = tuple(sets)
         Parent.__init__(self, category=category)
 
-    def _element_constructor_(self,x):
+    def _element_constructor_(self, x):
         r"""
         Construct an element of a Cartesian product from a list or iterable
 
@@ -141,7 +142,7 @@ def _repr_(self):
             sage: cartesian_product([QQ, ZZ, ZZ]) # indirect doctest
             The Cartesian product of (Rational Field, Integer Ring, Integer Ring)
         """
-        return "The Cartesian product of %s"%(self._sets,)
+        return "The Cartesian product of %s" % (self._sets,)
 
     def __contains__(self, x):
         """
@@ -160,8 +161,8 @@ def __contains__(self, x):
                 return True
         elif not isinstance(x, tuple):
             return False
-        return ( len(x) == len(self._sets)
-                 and all(elt in self._sets[i] for i,elt in enumerate(x)) )
+        return (len(x) == len(self._sets)
+                and all(elt in self._sets[i] for i, elt in enumerate(x)))
 
     def cartesian_factors(self):
         """

src/sage/sets/condition_set.py

@@ -204,7 +204,7 @@ def __init__(self, universe, *predicates, names=None, category=None):
         if isinstance(universe, Parent):
             facade = universe
         super().__init__(facade=facade, category=category,
-                         names=names, normalize=False) # names already normalized by classcall
+                         names=names, normalize=False)  # names already normalized by classcall
 
     def _first_ngens(self, n):
         r"""

src/sage/sets/disjoint_union_enumerated_sets.py

@@ -7,12 +7,12 @@
 - Florent Hivert (2010-03): classcall related stuff.
 - Florent Hivert (2010-12): fixed facade element construction.
 """
-#****************************************************************************
+# ***************************************************************************
 #  Copyright (C) 2009 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.element import Element
 from sage.structure.parent import Parent
@@ -25,6 +25,7 @@
 from sage.misc.lazy_attribute import lazy_attribute
 from sage.structure.unique_representation import UniqueRepresentation
 
+
 class DisjointUnionEnumeratedSets(UniqueRepresentation, Parent):
     """
     A class for disjoint unions of enumerated sets.
@@ -311,7 +312,7 @@ def _repr_(self):
             sage: U
             Disjoint union of Finite family {1: {1, 2, 3}, 2: {4, 5, 6}}
         """
-        return "Disjoint union of %s"%self._family
+        return "Disjoint union of %s" % self._family
 
     def _is_a(self, x):
         """
@@ -336,7 +337,7 @@ def _is_a(self, x):
         else:
             from warnings import warn
             if self._family.cardinality() == Infinity:
-                warn("%s is an infinite union\nThe default implementation of __contains__ can loop forever. Please overload it."%(self))
+                warn("%s is an infinite union\nThe default implementation of __contains__ can loop forever. Please overload it." % (self))
             return any(x in a for a in self._family)
 
     def __contains__(self, x):
@@ -404,7 +405,7 @@ def __iter__(self):
                 if self._facade:
                     yield el
                 else:
-                    yield self.element_class(self, el) # Bypass correctness tests
+                    yield self.element_class(self, el)  # Bypass correctness tests
 
     def an_element(self):
         """
@@ -515,7 +516,7 @@ def _element_constructor_default(self, el):
         if self._is_a(el):
             return self.element_class(self, el)
         else:
-            raise ValueError("value %s does not belong to %s"%(el, self))
+            raise ValueError("value %s does not belong to %s" % (el, self))
 
     def _element_constructor_facade(self, el):
         """
@@ -568,19 +569,19 @@ def _element_constructor_facade(self, el):
             try:
                 return (el[0], P(el[1]))
             except Exception:
-                raise ValueError("cannot coerce `%s` in the parent `%s`"%(el[1], P))
+                raise ValueError("cannot coerce `%s` in the parent `%s`" % (el[1], P))
 
         # Check first to see if the parent of el is in the family
         if (isinstance(el, Element) and self._facade_for is not True
-            and el.parent() in self._facade_for):
+                and el.parent() in self._facade_for):
             return el
 
         for P in self._family:
             try:
                 return P(el)
             except Exception:
                 pass
-        raise ValueError("cannot coerce `%s` in any parent in `%s`"%(el, self._family))
+        raise ValueError("cannot coerce `%s` in any parent in `%s`" % (el, self._family))
 
     @lazy_attribute
     def Element(self):

src/sage/sets/family.py

@@ -22,7 +22,7 @@
     Category of finite enumerated sets
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2008 Nicolas Thiery <nthiery at users.sf.net>,
 #                          Mike Hansen <[email protected]>,
 #                          Florent Hivert <[email protected]>
@@ -32,7 +32,7 @@
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
-#*****************************************************************************
+# ****************************************************************************
 import types
 from copy import copy
 from pprint import pformat, saferepr
@@ -48,8 +48,11 @@
 from sage.misc.lazy_import import lazy_import
 from sage.rings.integer import Integer
 from sage.misc.call import AttrCallObject
+from sage.sets.non_negative_integers import NonNegativeIntegers
+from sage.rings.infinity import Infinity
 lazy_import('sage.combinat.combinat', 'CombinatorialClass')
 
+
 def Family(indices, function=None, hidden_keys=[], hidden_function=None, lazy=False, name=None):
     r"""
     A Family is an associative container which models a family
@@ -389,19 +392,19 @@ def Family(indices, function=None, hidden_keys=[], hidden_function=None, lazy=Fa
                 raise ValueError("lazy keyword only makes sense together with function keyword")
             if isinstance(indices, dict):
                 return FiniteFamily(indices)
-            if isinstance(indices, (list, tuple) ):
+            if isinstance(indices, (list, tuple)):
                 return TrivialFamily(indices)
-            if isinstance(indices, (FiniteFamily, LazyFamily, TrivialFamily) ):
+            if isinstance(indices, (FiniteFamily, LazyFamily, TrivialFamily)):
                 return indices
             if (indices in EnumeratedSets()
-                or isinstance(indices, CombinatorialClass)):
+                    or isinstance(indices, CombinatorialClass)):
                 return EnumeratedFamily(indices)
             if isinstance(indices, Iterable):
                 return TrivialFamily(indices)
 
             raise NotImplementedError
         if (isinstance(indices, (list, tuple, FiniteEnumeratedSet))
-               and not lazy):
+                and not lazy):
             return FiniteFamily({i: function(i) for i in indices},
                                 keys=indices)
 
@@ -528,9 +531,9 @@ def inverse_family(self):
 
             sage: Family((3,4,7)).inverse_family()
             Finite family {3: 0, 4: 1, 7: 2}
-
         """
-        return Family( dict( (self[k], k) for k in self.keys()) )
+        return Family({self[k]: k for k in self.keys()})
+
 
 class FiniteFamily(AbstractFamily):
     r"""
@@ -654,7 +657,7 @@ def keys(self):
             ['c', 'a', 'b']
         """
         return (self._keys if self._keys is not None
-                           else list(self._dictionary))
+                else list(self._dictionary))
 
     def values(self):
         """
@@ -709,7 +712,7 @@ def __eq__(self, other):
             False
         """
         return (isinstance(other, self.__class__) and
-                self._keys       == other._keys and
+                self._keys == other._keys and
                 self._dictionary == other._dictionary)
 
     def _repr_(self):
@@ -825,6 +828,7 @@ def __setstate__(self, state):
         """
         self.__init__(state['dictionary'], keys=state.get("keys"))
 
+
 class FiniteFamilyWithHiddenKeys(FiniteFamily):
     r"""
     A close variant of :class:`FiniteFamily` where the family contains some
@@ -849,7 +853,7 @@ def __init__(self, dictionary, hidden_keys, hidden_function, keys=None):
 
         # would be better to define as usual method
         # any better to unset the def of __getitem__ by FiniteFamily?
-        #self.__getitem__ = lambda i: dictionary[i] if dictionary.has_key(i) else hidden_dictionary[i]
+        # self.__getitem__ = lambda i: dictionary[i] if dictionary.has_key(i) else hidden_dictionary[i]
 
     def __getitem__(self, i):
         """
@@ -919,7 +923,7 @@ def __setstate__(self, d):
         """
         hidden_function = d['hidden_function']
         if isinstance(hidden_function, str):
-        # Let's assume that hidden_function is an unpickled function.
+            # Let's assume that hidden_function is an unpickled function.
             from sage.misc.fpickle import unpickle_function
             hidden_function = unpickle_function(hidden_function)
         self.__init__(d['dictionary'], d['hidden_keys'], hidden_function)
@@ -1070,15 +1074,15 @@ def _repr_(self):
         """
         if self.function_name is not None:
             name = self.function_name + "(i)"
-        elif isinstance(self.function, type(lambda x:1)):
+        elif isinstance(self.function, type(lambda x: 1)):
             name = self.function.__name__
-            name = name+"(i)"
+            name = name + "(i)"
         else:
             name = repr(self.function)
             if isinstance(self.function, AttrCallObject):
-                name = "i"+name[1:]
+                name = "i" + name[1:]
             else:
-                name = name+"(i)"
+                name = name + "(i)"
         return "Lazy family ({})_{{i in {}}}".format(name, self.set)
 
     def keys(self):
@@ -1217,7 +1221,7 @@ def __setstate__(self, d):
         """
         function = d['function']
         if isinstance(function, bytes):
-        # Let's assume that function is an unpickled function.
+            # Let's assume that function is an unpickled function.
             from sage.misc.fpickle import unpickle_function
             function = unpickle_function(function)
 
@@ -1295,7 +1299,7 @@ def _repr_(self):
             sage: f = TrivialFamily([3,4,7]); f # indirect doctest
             Family (3, 4, 7)
         """
-        return "Family %s"%((self._enumeration),)
+        return "Family %s" % ((self._enumeration),)
 
     def keys(self):
         """
@@ -1399,9 +1403,6 @@ def map(self, f, name=None):
         return Family(tuple([f(x) for x in self._enumeration]), name=name)
 
 
-from sage.sets.non_negative_integers import NonNegativeIntegers
-from sage.rings.infinity import Infinity
-
 class EnumeratedFamily(LazyFamily):
     r"""
     :class:`EnumeratedFamily` turns an enumerated set ``c`` into a family
@@ -1468,8 +1469,8 @@ def __repr__(self):
         """
 #        return "Family ((%s)[i])_(i=1...%s)"%(self.enumset, self.enumset.cardinality())
         if isinstance(self.enumset, FiniteEnumeratedSet):
-            return "Family %s"%(self.enumset._elements,)
-        return "Family (%s)"%(self.enumset)
+            return "Family %s" % (self.enumset._elements,)
+        return "Family (%s)" % (self.enumset)
 
     def __contains__(self, x):
         """

src/sage/sets/finite_enumerated_set.py

@@ -23,7 +23,7 @@
 from sage.categories.sets_cat import EmptySetError
 from sage.rings.integer import Integer
 
-#################################################################
+
 class FiniteEnumeratedSet(UniqueRepresentation, Parent):
     """
     A class for finite enumerated set.
@@ -271,7 +271,7 @@ def rank(self, x):
 
     index = rank
 
-    def unrank(self,i):
+    def unrank(self, i):
         r"""
         Return the element at position ``i``.
 
@@ -402,5 +402,5 @@ def _element_constructor_(self, el):
         """
         try:
             return self._elements[self.rank(el)]
-        except (ValueError,KeyError):
-            raise ValueError("%s not in %s"%(el, self))
+        except (ValueError, KeyError):
+            raise ValueError("%s not in %s" % (el, self))