Merge pull request #17 from edgarcosta/autopep8-patches

Fixes by autopep8 action

Author: edgarcosta

lmfdb/api/api.py

@@ -289,7 +289,7 @@ def apierror(msg, flash_extras=[], code=404, table=True):
     if 'bytea' in coll.col_type.values():
         for row in data:
             for key, val in row.items():
-                if type(val) == buffer:
+                if isinstance(val, buffer):
                     row[key] = "[binary data]"
         #data = [ dict([ (key, val if coll.col_type[key] != 'bytea' else "binary data") for key, val in row.items() ]) for row in data]
     data = Json.prep(data)

lmfdb/app.py

@@ -275,8 +275,8 @@ def netloc_redirect():
         return redirect(url, code=301)
     elif (
         urlparts.netloc == "www.lmfdb.org"
-        and
-        not white_listed(urlparts.path)
+
+        and not white_listed(urlparts.path)
         and valid_bread(urlparts.path)
     ):
         replaced = urlparts._replace(netloc="beta.lmfdb.org", scheme="https")

lmfdb/backend/statstable.py

@@ -564,7 +564,7 @@ def column_counts(self, cols, constraint=None, threshold=1, split_list=False):
         ).format(Identifier(self.counts), thresh)
         cur = self._execute(selecter, [jallcols, split_list])
         if one_col:
-            _make_tuple = lambda x: make_tuple(x)[0]
+            def _make_tuple(x): return make_tuple(x)[0]
         else:
             _make_tuple = make_tuple
         if constraint is None:
@@ -1096,7 +1096,7 @@ def numstats(self, col, grouping, constraint=None, threshold=None):
         selecter = selecter.format(Identifier(self.stats), threshold)
         nstats = defaultdict(dict)
         if onegroup:
-            _make_tuple = lambda x: make_tuple(x)[0]
+            def _make_tuple(x): return make_tuple(x)[0]
         else:
             _make_tuple = make_tuple
         for rec in self._execute(selecter, values):

lmfdb/bianchi_modular_forms/bianchi_modular_form.py

@@ -283,8 +283,7 @@ def bmf_field_dim_table(**args):
     weights = set()
     for dat in data:
         weights = weights.union(set(dat[gl_or_sl].keys()))
-    weights = [int(w) for w in weights]
-    weights.sort()
+    weights = sorted([int(w) for w in weights])
     info['weights'] = weights
     info['nweights'] = len(weights)
 

lmfdb/characters/ListCharacters.py

@@ -72,7 +72,7 @@ def get_character_modulus(a, b, limit=7):
                 entry.append(el)
                 entries[(row, col)] = entry
     entries2 = {}
-    out = lambda chi: (chi.number, chi.is_primitive(),
+    def out(chi): return (chi.number, chi.is_primitive(),
                        chi.multiplicative_order(), chi.is_even())
     for k, v in entries.items():
         l = []

lmfdb/characters/web_character.py

@@ -265,7 +265,7 @@ def prevprimchar(m, n):
     def nextprimchar(m, n):
         if m < 3:
             return 3, 2
-        while 1:
+        while True:
             n += 1
             if n >= m:
                 m, n = m + 1, 2
@@ -721,8 +721,7 @@ def __init__(self, **args):
     def structure(self):
         inv = self.H.invariants()
         if inv:
-            inv_list = list(inv)
-            inv_list.sort()
+            inv_list = sorted(inv)
             return r"\(%s\)" % ("\\times ".join("C_{%s}" % d for d in inv_list))
         else:
             return r"\(C_1\)"

lmfdb/classical_modular_forms/main.py

@@ -1023,8 +1023,8 @@ def delete_false(D):
 
 def dimension_space_postprocess(res, info, query):
     if ((query.get('weight_parity') == -1 and query.get('char_parity') == 1)
-            or
-        (query.get('weight_parity') == 1 and query.get('char_parity') == -1)):
+
+        or (query.get('weight_parity') == 1 and query.get('char_parity') == -1)):
         raise ValueError("Inconsistent parity for character and weight")
     urlgen_info = dict(info)
     urlgen_info['count'] = 50

lmfdb/classical_modular_forms/test_cmf.py

@@ -550,30 +550,30 @@ def test_satake(self):
 
     def test_underlying_data(self):
         data = self.tc.get('/ModularForm/GL2/Q/holomorphic/data/13.2').get_data(as_text=True)
-        assert ('mf_gamma1' in data and 'newspace_dims' in data and
-                'mf_gamma1_subspaces' in data and 'sub_mult' in data and
-                'mf_gamma1_portraits' in data and "data:image/png;base64" in data)
+        assert ('mf_gamma1' in data and 'newspace_dims' in data
+                and 'mf_gamma1_subspaces' in data and 'sub_mult' in data
+                and 'mf_gamma1_portraits' in data and "data:image/png;base64" in data)
 
         data = self.tc.get('/ModularForm/GL2/Q/holomorphic/data/13.2.e').get_data(as_text=True)
-        assert ('mf_newspaces' in data and 'num_forms' in data and
-                'mf_subspaces' in data and 'sub_mult' in data and
-                'mf_newspace_portraits' in data and "data:image/png;base64" in data and
-                'mf_hecke_newspace_traces' in data and 'trace_an' in data)
+        assert ('mf_newspaces' in data and 'num_forms' in data
+                and 'mf_subspaces' in data and 'sub_mult' in data
+                and 'mf_newspace_portraits' in data and "data:image/png;base64" in data
+                and 'mf_hecke_newspace_traces' in data and 'trace_an' in data)
 
         data = self.tc.get('/ModularForm/GL2/Q/holomorphic/data/13.2.e.a').get_data(as_text=True)
         assert ('mf_newforms' in data and 'field_disc_factorization' in data and
-                'mf_hecke_nf' in data and 'hecke_ring_character_values' in data and
-                'mf_newspaces' in data and 'num_forms' in data and
-                'mf_twists_nf' in data and 'twisting_char_label' in data and
-                'mf_hecke_charpolys' in data and 'charpoly_factorization' in data and
-                'mf_newform_portraits' in data and "data:image/png;base64" in data and
-                'mf_hecke_traces' in data and 'trace_an' in data)
+                'mf_hecke_nf' in data and 'hecke_ring_character_values' in data
+                and 'mf_newspaces' in data and 'num_forms' in data
+                and 'mf_twists_nf' in data and 'twisting_char_label' in data
+                and 'mf_hecke_charpolys' in data and 'charpoly_factorization' in data
+                and 'mf_newform_portraits' in data and "data:image/png;base64" in data
+                and 'mf_hecke_traces' in data and 'trace_an' in data)
 
         data = self.tc.get('/ModularForm/GL2/Q/holomorphic/data/13.2.e.a.4.1').get_data(as_text=True)
         assert ('mf_newforms' in data and 'field_disc_factorization' in data and
-                'mf_hecke_cc' in data and 'an_normalized' in data and
-                'mf_newspaces' in data and 'num_forms' in data and
-                'mf_twists_cc' in data and 'twisting_conrey_index' in data and
-                'mf_hecke_charpolys' in data and 'charpoly_factorization' in data and
-                'mf_newform_portraits' in data and "data:image/png;base64" in data and
-                'mf_hecke_traces' in data and 'trace_an' in data)
+                'mf_hecke_cc' in data and 'an_normalized' in data
+                and 'mf_newspaces' in data and 'num_forms' in data
+                and 'mf_twists_cc' in data and 'twisting_conrey_index' in data
+                and 'mf_hecke_charpolys' in data and 'charpoly_factorization' in data
+                and 'mf_newform_portraits' in data and "data:image/png;base64" in data
+                and 'mf_hecke_traces' in data and 'trace_an' in data)

lmfdb/classical_modular_forms/web_newform.py

@@ -297,8 +297,8 @@ def convert_qexp_to_cyclotomic(self, m):
         zeta = F.gens()[0]
         ret = []
         l = len(self.hecke_ring_numerators)
-        betas = [F(self.hecke_ring_numerators[i]) /
-                 self.hecke_ring_denominators[i] for i in range(l)]
+        betas = [F(self.hecke_ring_numerators[i])
+                 / self.hecke_ring_denominators[i] for i in range(l)]
         write_in_powers = zeta.coordinates_in_terms_of_powers()
         for coeffs in self.qexp:
             elt = sum([coeffs[i] * betas[i] for i in range(l)])
@@ -339,8 +339,8 @@ def friends(self):
         nf_url = ns_url + '/' + self.hecke_orbit_label
         if self.embedding_label is not None:
             res.append(('Newform orbit ' + self.label, nf_url))
-            if (self.dual_label is not None and
-                    self.dual_label != self.embedding_label):
+            if (self.dual_label is not None
+                    and self.dual_label != self.embedding_label):
                 dlabel = self.label + '.' + self.dual_label
                 d_url = nf_url + '/' + self.dual_label.replace('.', '/') + '/'
                 res.append(('Dual form ' + dlabel, d_url))

lmfdb/ecnf/WebEllipticCurve.py

@@ -457,8 +457,8 @@ def make_E(self):
             self.ar = "not available"
 
         # for debugging:
-        assert self.rk == "not available" or (self.rk_lb == self.rank and
-                                              self.rank == self.rk_ub)
+        assert self.rk == "not available" or (self.rk_lb == self.rank
+                                              and self.rank == self.rk_ub)
         assert self.ar=="not available" or (self.rk_lb<=self.analytic_rank and self.analytic_rank<=self.rk_ub)
 
         self.bsd_status = "incomplete"

lmfdb/elliptic_curves/elliptic_curve.py

@@ -1009,10 +1009,10 @@ def __init__(self):
             example="1728",
             example_span="1728 or -4096/11")
         # ℤ is ℤ in html
-        torsion_opts = ([("", ""), ("[]", "trivial")] +
-                        [("%s" % n, "order %s" % n) for n in range(4, 16, 4)] +
-                        [("[%s]" % n, "ℤ/%sℤ" % n) for n in range(2, 13) if n != 11] +
-                        [("[2,%s]" % n, "ℤ/2ℤ⊕ℤ/%sℤ" % n) for n in range(2, 10, 2)])
+        torsion_opts = ([("", ""), ("[]", "trivial")]
+                        + [("%s" % n, "order %s" % n) for n in range(4, 16, 4)]
+                        + [("[%s]" % n, "ℤ/%sℤ" % n) for n in range(2, 13) if n != 11]
+                        + [("[2,%s]" % n, "ℤ/2ℤ⊕ℤ/%sℤ" % n) for n in range(2, 10, 2)])
         torsion = SelectBox(
             name="torsion",
             label="Torsion",
@@ -1080,9 +1080,9 @@ def __init__(self):
             knowl="ec.maximal_elladic_galois_rep",
             example="2,3",
             select_box=nonmax_quant)
-        cm_opts = ([('', ''), ('noCM', 'no potential CM'), ('CM', 'potential CM')] +
-                   [('-4,-16', 'CM field Q(sqrt(-1))'), ('-3,-12,-27', 'CM field Q(sqrt(-3))'), ('-7,-28', 'CM field Q(sqrt(-7))')] +
-                   [('-%d'%d, 'CM discriminant -%d'%d) for d in [3,4,7,8,11,12,16,19,27,28,43,67,163]])
+        cm_opts = ([('', ''), ('noCM', 'no potential CM'), ('CM', 'potential CM')]
+                   + [('-4,-16', 'CM field Q(sqrt(-1))'), ('-3,-12,-27', 'CM field Q(sqrt(-3))'), ('-7,-28', 'CM field Q(sqrt(-7))')]
+                   + [('-%d'%d, 'CM discriminant -%d'%d) for d in [3,4,7,8,11,12,16,19,27,28,43,67,163]])
         cm = SelectBox(
             name="cm",
             label="Complex multiplication",

lmfdb/elliptic_curves/isog_class.py

@@ -115,7 +115,7 @@ def make_class(self):
         # permute rows/cols to match labelling: the rows/cols in the
         # ec_classdata table are with respect to LMFDB ordering.
         if self.label_type == 'Cremona':
-            perm = lambda i: next(c for c in self.curves if c['Cnumber']==i+1)['lmfdb_number']-1
+            def perm(i): return next(c for c in self.curves if c['Cnumber']==i+1)['lmfdb_number']-1
             M = [[M[perm(i)][perm(j)] for i in range(ncurves)] for j in range(ncurves)]
 
         M = Matrix(M)

lmfdb/elliptic_curves/web_ec.py

@@ -71,8 +71,8 @@ def gl2_subgroup_data(label):
     except ValueError:
         return "Unable to locate data for GL(2,Zhat) subgroup with label: %s" % label
 
-    row_wrap = lambda cap, val: "<tr><td>%s: </td><td>%s</td></tr>\n" % (cap, val)
-    matrix = lambda m: r'$\begin{bmatrix}%s&%s\\%s&%s\end{bmatrix}$' % (m[0],m[1],m[2],m[3])
+    def row_wrap(cap, val): return "<tr><td>%s: </td><td>%s</td></tr>\n" % (cap, val)
+    def matrix(m): return r'$\begin{bmatrix}%s&%s\\%s&%s\end{bmatrix}$' % (m[0],m[1],m[2],m[3])
     info = '<table>\n'
     info += row_wrap('Subgroup <b>%s</b>' % (label), "<small>" + ', '.join(matrix(m) for m in data['generators']) + "</small>")
     info += "<tr><td></td><td></td></tr>\n"

lmfdb/galois_groups/transitive_group.py

@@ -477,8 +477,7 @@ def subfield_display(n, subs):
 def otherrep_display(n, t, reps):
     reps = [(j[0], j[1]) for j in reps]
     me = (n, t)
-    difreps = list(set(reps))
-    difreps.sort()
+    difreps = sorted(set(reps))
     ans = ''
     for k in difreps:
         if ans != '':

lmfdb/genus2_curves/test_genus2_curves.py

@@ -349,11 +349,11 @@ def test_related_objects(self):
     def test_underlying_data(self):
         data = self.tc.get("/Genus2Curve/Q/data/576.a.576.1").get_data(as_text=True)
         assert ('g2c_curves' in data and 'bad_lfactors' in data and
-                'g2c_endomorphisms' in data and 'factorsQQ_base' in data and
-                'g2c_ratpts' in data and 'mw_gens_v' in data and
-                'g2c_galrep' in data and 'modell_image' in data and
-                'g2c_tamagawa' in data and 'tamagawa_number' in data and
-                'g2c_plots' in data and "data:image/png;base64" in data)
+                'g2c_endomorphisms' in data and 'factorsQQ_base' in data
+                and 'g2c_ratpts' in data and 'mw_gens_v' in data
+                and 'g2c_galrep' in data and 'modell_image' in data
+                and 'g2c_tamagawa' in data and 'tamagawa_number' in data
+                and 'g2c_plots' in data and "data:image/png;base64" in data)
 
     def test_jump(self):
         from sage.all import magma

lmfdb/genus2_curves/web_g2c.py

@@ -519,8 +519,9 @@ def gsp4_subgroup_data(label):
         data = db.gps_gsp4zhat.lookup(label)
     except ValueError:
         return "Invalid label for subgroup of GSp(4,Zhat): %s" % label
-    row_wrap = lambda cap, val: "<tr><td>%s: </td><td>%s</td></tr>\n" % (cap, val)
-    matrix = lambda m: r'$\begin{bmatrix}%s&%s&%s&%s\\%s&%s&%s&%s\\%s&%s&%s&%s\\%s&%s&%s&%s\end{bmatrix}$' % (m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7],m[8],m[9],m[10],m[11],m[12],m[13],m[14],m[15])
+
+    def row_wrap(cap, val): return "<tr><td>%s: </td><td>%s</td></tr>\n" % (cap, val)
+    def matrix(m): return r'$\begin{bmatrix}%s&%s&%s&%s\\%s&%s&%s&%s\\%s&%s&%s&%s\\%s&%s&%s&%s\end{bmatrix}$' % (m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7],m[8],m[9],m[10],m[11],m[12],m[13],m[14],m[15])
     info = '<table>\n'
     info += row_wrap('Subgroup <b>%s</b>' % (label), "<small>" + ', '.join(matrix(m) for m in data['generators']) + "</small>")
     info += "<tr><td></td><td></td></tr>\n"
@@ -920,8 +921,8 @@ def make_object(self, curve, endo, tama, ratpts, clus, galrep, is_curve):
         data['gl2_statement_base'] = gl2_statement_base(endo['factorsRR_base'], r'\(\Q\)')
         data['factorsQQ_base'] = endo['factorsQQ_base']
         data['factorsRR_base'] = endo['factorsRR_base']
-        data['end_statement_base'] = (r"Endomorphism %s over \(\Q\):<br>" % ("ring" if is_curve else "algebra") +
-            end_statement(data['factorsQQ_base'], endo['factorsRR_base'], ring=data['end_ring_base'] if is_curve else None))
+        data['end_statement_base'] = (r"Endomorphism %s over \(\Q\):<br>" % ("ring" if is_curve else "algebra")
+            + end_statement(data['factorsQQ_base'], endo['factorsRR_base'], ring=data['end_ring_base'] if is_curve else None))
 
         # Field over which all endomorphisms are defined
         data['end_field_label'] = endo['fod_label']
@@ -933,8 +934,8 @@ def make_object(self, curve, endo, tama, ratpts, clus, galrep, is_curve):
         data['factorsRR_geom'] = endo['factorsRR_geom']
         if data['end_field_label'] != '1.1.1.1':
             data['gl2_statement_geom'] = gl2_statement_base(data['factorsRR_geom'], r'\(\overline{\Q}\)')
-            data['end_statement_geom'] = (r"Endomorphism %s over \(\overline{\Q}\):" % ("ring" if is_curve else "algebra") +
-                end_statement(data['factorsQQ_geom'], data['factorsRR_geom'], field=r'\overline{\Q}', ring=data['end_ring_geom'] if is_curve else None))
+            data['end_statement_geom'] = (r"Endomorphism %s over \(\overline{\Q}\):" % ("ring" if is_curve else "algebra")
+                + end_statement(data['factorsQQ_geom'], data['factorsRR_geom'], field=r'\overline{\Q}', ring=data['end_ring_geom'] if is_curve else None))
         data['real_geom_end_alg_name'] = real_geom_end_alg_name(curve['real_geom_end_alg'])
         data['geom_end_alg_name'] = geom_end_alg_name(curve['geom_end_alg'])
         data['end_alg_name'] = end_alg_name(curve['end_alg'])

lmfdb/groups/abstract/groups_test_pages.py

@@ -74,8 +74,7 @@ def all_abstract_groups(self, maxord=None, chunksize=1000):
         res = sum((outp for (inp, outp) in self.abstract_groups_of_order(inputs)), [])
         errors = [url for (t, url) in res if t is None]
         errors
-        working_urls = [(t, url) for (t, url) in res if t is not None]
-        working_urls.sort()
+        working_urls = sorted([(t, url) for (t, url) in res if t is not None])
         times = [t for (t, url) in working_urls]
         total = len(times)
         if errors:

lmfdb/hecke_algebras/main.py

@@ -115,7 +115,7 @@ def download_search(info):
     s += download_assignment_start[lang] + list_start + '\\\n'
     mat_start = "Mat(" if lang == 'gp' else "Matrix("
     mat_end = "~)" if lang == 'gp' else ")"
-    entry = lambda r: "".join([mat_start,str(r),mat_end])
+    def entry(r): return "".join([mat_start,str(r),mat_end])
     # loop through all search results and grab the Hecke operators stored
     for c, rr in enumerate(res):
         s += list_start
@@ -433,7 +433,7 @@ def download_hecke_algebras_full_lists_op(**args):
     c = download_comment_prefix[lang]
     mat_start = "Mat(" if lang == 'gp' else "Matrix("
     mat_end = "~)" if lang == 'gp' else ")"
-    entry = lambda r: "".join([mat_start, str(r), mat_end])
+    def entry(r): return "".join([mat_start, str(r), mat_end])
 
     outstr = c + 'Hecke algebra for Gamma0(%s) and weight %s, orbit label %s. List of Hecke operators T_1, ..., T_%s. Downloaded from the LMFDB on %s. \n\n'%(res['level'], res['weight'], res['orbit_label'],res['num_hecke_op'], mydate)
     outstr += download_assignment_start[lang] + '[\\\n'
@@ -453,7 +453,7 @@ def download_hecke_algebras_full_lists_gen(**args):
     c = download_comment_prefix[lang]
     mat_start = "Mat(" if lang == 'gp' else "Matrix("
     mat_end = "~)" if lang == 'gp' else ")"
-    entry = lambda r: "".join([mat_start,str(r),mat_end])
+    def entry(r): return "".join([mat_start,str(r),mat_end])
 
     outstr = c + 'Hecke algebra for Gamma0(%s) and weight %s, orbit label %s. List of generators for the algebra. Downloaded from the LMFDB on %s. \n\n'%(res['level'], res['weight'], res['orbit_label'], mydate)
     outstr += download_assignment_start[lang] + '[\\\n'
@@ -489,7 +489,7 @@ def download_hecke_algebras_full_lists_mod_op(**args):
     field='GF(%s), %s, %s, '%(res['ell'], sqrt(len(res['operators'][0])), sqrt(len(res['operators'][0])))
     mat_start = "Mat("+field if lang == 'gp' else "Matrix("+field
     mat_end = "~)" if lang == 'gp' else ")"
-    entry = lambda r: "".join([mat_start,str(r),mat_end])
+    def entry(r): return "".join([mat_start,str(r),mat_end])
 
     outstr = c + ' List of Hecke operators T_1, ..., T_%s mod %s for orbit %s index %s downloaded from the LMFDB on %s. \n\n'%(len(res['operators']), ell, label, index, mydate)
     outstr += download_assignment_start[lang] +'[\\\n'

lmfdb/higher_genus_w_automorphisms/main.py

@@ -126,8 +126,7 @@ def split_perm(strg):
             startpoint = i+1
 
 def sort_sign(L):
-    L1 = L[1:]
-    L1.sort()
+    L1 = sorted(L[1:])
     return [L[0]] + L1
 
 def label_to_breadcrumbs(L):
@@ -505,9 +504,9 @@ def hgcwa_code_download_search(info):
 def parse_range2_extend(arg, key, parse_singleton=int, parse_endpoint=None, instance=1):
     if parse_endpoint is None:
         parse_endpoint = parse_singleton
-    if type(arg) == str:
+    if isinstance(arg, str):
         arg = arg.replace(' ', '')
-    if type(arg) == parse_singleton:
+    if isinstance(arg, parse_singleton):
         return [key, arg]
     if ',' in arg:
         instance = len(arg.split(','))
@@ -526,8 +525,7 @@ def parse_range2_extend(arg, key, parse_singleton=int, parse_endpoint=None, inst
     elif 'g' in arg: # linear function of variable g (ax+b)
         if GENUS_RE.match(arg):
             a = GENUS_RE.match(arg).groups()[0]
-            genus_list = db.hgcwa_passports.distinct('genus')
-            genus_list.sort()
+            genus_list = sorted(db.hgcwa_passports.distinct('genus'))
             min_genus = genus_list[0]
             max_genus = genus_list[-1]
             queries = []