def __init__(self, loggername, db): # Have to record this object in the db so that we can reset the connection if necessary. # This function also sets self.conn db.register_object(self) self._db = db from lmfdb.utils.config import Configuration logging_options = Configuration().get_logging() self.slow_cutoff = logging_options["slowcutoff"] handler = logging.FileHandler(logging_options["slowlogfile"]) formatter = logging.Formatter("%(asctime)s - %(message)s") filt = QueryLogFilter() handler.setFormatter(formatter) handler.addFilter(filt) self.logger = make_logger(loggername, hl=False, extraHandlers=[handler])
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint abvarfq_page = Blueprint("abvarfq", __name__, template_folder='templates', static_folder="static") abvarfq_logger = make_logger(abvarfq_page) @abvarfq_page.context_processor def body_class(): return {'body_class': 'abvarfq'} import main assert main app.register_blueprint(abvarfq_page, url_prefix="/Variety/Abelian/Fq")
# -*- coding: utf-8 -*- from collections import Counter import os, yaml from flask import url_for from sage.all import ( gcd, Set, ZZ, is_even, is_odd, euler_phi, CyclotomicField, gap, RealField, AbelianGroup, QQ, gp, NumberField, PolynomialRing, latex, pari, cached_function) from lmfdb import db from lmfdb.utils import (web_latex, coeff_to_poly, pol_to_html, display_multiset, factor_base_factor, factor_base_factorization_latex) from lmfdb.logger import make_logger from lmfdb.galois_groups.transitive_group import WebGaloisGroup, group_display_knowl, galois_module_knowl, group_pretty_and_nTj wnflog = make_logger("WNF") dir_group_size_bound = 10000 dnc = 'data not computed' # Dictionary of field label: n for abs(disc(Q(zeta_n))) # Does all cyclotomic fields of degree n s.t. 2<n<24 cycloinfo = {'4.0.125.1': 5, '6.0.16807.1': 7, '4.0.256.1': 8, '6.0.19683.1': 9, '10.0.2357947691.1': 11, '4.0.144.1': 12, '12.0.1792160394037.1': 13, '8.0.1265625.1': 15, '8.0.16777216.1': 16, '16.0.2862423051509815793.1': 17, '18.0.5480386857784802185939.1': 19, '8.0.4000000.1': 20, '12.0.205924456521.1': 21, '22.0.39471584120695485887249589623.1': 23, '8.0.5308416.1': 24, '20.0.2910383045673370361328125.1': 25, '18.0.2954312706550833698643.1': 27, '12.0.1157018619904.1': 28, '16.0.18446744073709551616.1': 32, '20.0.328307557444402776721569.1': 33, '24.0.304383340063522342681884765625.1': 35,
from seminars.utils import ( format_errmsg, ics_file, show_input_errors, timestamp, timezones, topdomain, validate_url, ) from seminars.tokens import generate_timed_token, read_timed_token, read_token from datetime import datetime login_page = Blueprint("user", __name__, template_folder="templates") logger = make_logger(login_page) login_manager = LoginManager() from .pwdmanager import userdb, SeminarsUser, SeminarsAnonymousUser @login_manager.user_loader def load_user(uid): return SeminarsUser(uid) login_manager.login_view = "user.info" login_manager.anonymous_user = SeminarsAnonymousUser
# -*- coding: utf-8 -*- from __future__ import absolute_import from .main import login_page, login_manager, admin_required, housekeeping assert admin_required # silence pyflakes assert housekeeping # silence pyflakes from flask_login import __version__ as FLASK_LOGIN_VERSION from seminars.app import app from lmfdb.logger import make_logger from distutils.version import StrictVersion # secret key, necessary for sessions, and sessions are # in turn necessary for users to login app.secret_key = "vVjYyCM99DtirZqMaGMrle" login_manager.init_app(app) app.register_blueprint(login_page, url_prefix="/user") users_logger = make_logger("user", hl=True) FLASK_LOGIN_LIMIT = "0.3.0" if StrictVersion(FLASK_LOGIN_VERSION) < StrictVersion(FLASK_LOGIN_LIMIT): raise RuntimeError( "flask-login is older than version {version} and must be updated, perhaps through `sage -pip install flask-login`" .format(version=FLASK_LOGIN_LIMIT))
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint higher_genus_w_automorphisms_page = Blueprint("higher_genus_w_automorphisms", __name__, template_folder='templates', static_folder="static") logger = make_logger(higher_genus_w_automorphisms_page) @higher_genus_w_automorphisms_page.context_processor def body_class(): return {'body_class': 'higher_genus_w_automorphisms'} import main assert main # silence pyflakes app.register_blueprint(higher_genus_w_automorphisms_page, url_prefix="/HigherGenus/C/Aut")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint g2c_page = Blueprint("g2c", __name__, template_folder='templates', static_folder="static") g2c_logger = make_logger(g2c_page) @g2c_page.context_processor def body_class(): return {'body_class': 'g2c'} import main assert main # silence pyflakes app.register_blueprint(g2c_page, url_prefix="/Genus2Curve")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint from lmfdb.api2.searchers import register_search_function, register_singleton import searchers ec_page = Blueprint("ec", __name__, template_folder='templates', static_folder="static") ec_logger = make_logger(ec_page) #ec_logger.info("Initializing elliptic curves blueprint") @ec_page.context_processor def body_class(): return {'body_class': 'ec'} import elliptic_curve assert elliptic_curve # for pyflakes app.register_blueprint(ec_page, url_prefix="/EllipticCurve/Q") register_search_function("elliptic_curves_q", "Elliptic Curves over Rationals", "Search over elliptic curves defined over rationals", auto_search = 'ec_curves') register_singleton('EllipticCurve/Q', 'ec_curves', simple_search = searchers.ec_simple_label_search)
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint artin_representations_page = Blueprint( "artin_representations", __name__, template_folder='templates', static_folder="static") artin_logger = make_logger("artin", hl=True) # artin_logger.info("Initializing Artin representations blueprint") @artin_representations_page.context_processor def body_class(): return {'body_class': 'artin_representations'} import main assert main # silence pyflakes app.register_blueprint(artin_representations_page, url_prefix="/ArtinRepresentation")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint galois_groups_page = Blueprint("galois_groups", __name__, template_folder='templates', static_folder="static") logger = make_logger(galois_groups_page) @galois_groups_page.context_processor def body_class(): return {'body_class': 'galois_groups'} import main assert main app.register_blueprint(galois_groups_page, url_prefix="/GaloisGroup")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint permutations_page = Blueprint("permutations", __name__, template_folder='templates', static_folder="static") logger = make_logger(permutations_page) @permutations_page.context_processor def body_class(): return {'body_class': 'Permutations'} import main assert main app.register_blueprint(permutations_page, url_prefix="/Permutations")
def field_data(s): r""" Returns full field data from field label. """ deg, r1, abs_disc, n = [int(c) for c in s.split(".")] sig = [r1, (deg - r1) // 2] return [s, deg, sig, abs_disc] def sort_field(F): r""" Returns data to sort by, from field label. """ return [int(c) for c in F.split(".")] logger = make_logger("ecnf") class ECNF_stats(StatsDisplay): ec_knowls = '<a knowl="ec">elliptic curves</a>' ec_knowl = '<a knowl="ec">elliptic curve</a>' iso_knowls = '<a knowl="ec.isogeny_class">isogeny classes</a>' iso_knowl = '<a knowl="ec.isogeny_class">isogeny class</a>' nf_knowls = '<a knowl="nf">number fields</a>' nf_knowl = '<a knowl="nf">number field</a>' deg_knowl = '<a knowl="nf.degree">degree</a>' cond_knowls = '<a knowl="ec.conductor">conductors</a>' cond_knowl = '<a knowl="ec.conductor">conductor</a>' @lazy_attribute def ncurves(self): return db.ec_nfcurves.count() @lazy_attribute
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint cmf_page = Blueprint("cmf", __name__, template_folder='templates', static_folder="static") cmf = cmf_page cmf_logger = make_logger(cmf_page) import main assert main # silence pyflakes app.register_blueprint(cmf_page, url_prefix="/ModularForm/GL2/Q/holomorphic")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint nf_page = Blueprint("number_fields", __name__, template_folder='templates', static_folder="static") nf_logger = make_logger(nf_page) @nf_page.context_processor def body_class(): return {'body_class': 'nf'} import number_field assert number_field app.register_blueprint(nf_page, url_prefix="/NumberField")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint hiwf_page = Blueprint("hiwf", __name__, template_folder='templates', static_folder="static") hiwf_logger = make_logger(hiwf_page) @hiwf_page.context_processor def body_class(): return {'body_class': 'hiwf'} import half_integral_form assert half_integral_form app.register_blueprint(hiwf_page, url_prefix="/ModularForm/GL2/Q/holomorphic/half")
# -*- coding: utf-8 -*- from flask import url_for from lmfdb import db from lmfdb.utils import encode_plot, names_and_urls, web_latex from lmfdb.logger import make_logger from lmfdb.ecnf.WebEllipticCurve import web_ainvs, FIELD from lmfdb.number_fields.web_number_field import field_pretty, nf_display_knowl from sage.all import latex, Matrix, ZZ, Infinity from lmfdb.lfunctions.LfunctionDatabase import (get_lfunction_by_url, get_instances_by_Lhash_and_trace_hash) logger = make_logger("ecnf") class ECNF_isoclass(object): """ Class for an isogeny class of elliptic curves over Q """ def __init__(self, dbdata): """ Arguments: - dbdata: the data from the database """ #logger.info("Constructing an instance of ECNF_isoclass") self.__dict__.update(dbdata) self.make_class() @staticmethod
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint hiwf_page = Blueprint("hiwf", __name__, template_folder='templates', static_folder="static") hiwf_logger = make_logger(hiwf_page) @hiwf_page.context_processor def body_class(): return {'body_class': 'hiwf'} from . import half_integral_form assert half_integral_form app.register_blueprint(hiwf_page, url_prefix="/ModularForm/GL2/Q/holomorphic/half")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.utils import comma, format_percentage from lmfdb.logger import make_logger from lmfdb import db from flask import url_for logger = make_logger("ec") the_ECstats = None def get_stats(): global the_ECstats if the_ECstats is None: the_ECstats = ECstats() return the_ECstats def elliptic_curve_summary(): counts = get_stats().counts() ecstaturl = url_for('ec.statistics') return r'The database currently contains the Cremona database of all %s <a title="Elliptic curves [ec]" knowl="ec" kwargs="">elliptic curves</a> defined over $\Q$ with <a title="Conductor of an elliptic curve over $\Q$ [ec.q.conductor]" knowl="ec.q.conductor" kwargs="">conductor</a> at most %s, all of which have <a title="Rank of an elliptic curve over $\mathbb{Q}$ [ec.rank]" knowl="ec.rank" kwargs="">rank</a> $\leq %s$. Here are some <a href="%s">further statistics</a>.' % (str(counts['ncurves_c']), str(counts['max_N_c']), str(counts['max_rank']), ecstaturl) @app.context_processor def ctx_elliptic_curve_summary(): return {'elliptic_curve_summary': elliptic_curve_summary} class ECstats(object): """ Class for creating and displaying statistics for elliptic curves over Q """
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint hecke_algebras_page = Blueprint("hecke_algebras", __name__, template_folder='templates', static_folder="static") hecke_algebras_logger = make_logger(hecke_algebras_page) @hecke_algebras_page.context_processor def body_class(): return {'body_class': 'hecke_algebras'} import main assert main app.register_blueprint(hecke_algebras_page, url_prefix="/ModularForm/GL2/Q/HeckeAlgebra")
# -*- coding: utf-8 -*- from lmfdb.logger import make_logger from flask import Blueprint MWF = "mwf" # Maass waveforms mwf = Blueprint(MWF, __name__, template_folder="views/templates", static_folder="views/static") mwf_logger = make_logger(mwf) import backend assert backend import views assert views
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint abvar_page = Blueprint("abvar", __name__, template_folder='templates', static_folder="static") abvar_logger = make_logger(abvar_page) @abvar_page.context_processor def body_class(): return {'body_class': 'abvar'} app.register_blueprint(abvar_page, url_prefix="/Variety/Abelian")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint rep_galois_modl_page = Blueprint("rep_galois_modl", __name__, template_folder='templates', static_folder="static") rep_galois_modl_logger = make_logger(rep_galois_modl_page) @rep_galois_modl_page.context_processor def body_class(): return {'body_class': 'rep_galois_modl'} import main assert main #silence pyflakes app.register_blueprint(rep_galois_modl_page, url_prefix="/Representation/Galois/ModL")
from collections import Counter import os, yaml from flask import url_for from sage.all import (gcd, Set, ZZ, is_even, is_odd, euler_phi, CyclotomicField, gap, RealField, AbelianGroup, QQ, gp, NumberField, PolynomialRing, latex, pari, cached_function) from lmfdb import db from lmfdb.utils import (web_latex, coeff_to_poly, pol_to_html, display_multiset, factor_base_factor, factor_base_factorization_latex) from lmfdb.logger import make_logger from lmfdb.galois_groups.transitive_group import WebGaloisGroup, group_display_knowl, galois_module_knowl, group_pretty_and_nTj wnflog = make_logger("WNF") dir_group_size_bound = 10000 dnc = 'data not computed' # Dictionary of field label: n for abs(disc(Q(zeta_n))) # Does all cyclotomic fields of degree n s.t. 2<n<24 cycloinfo = { '4.0.125.1': 5, '6.0.16807.1': 7, '4.0.256.1': 8, '6.0.19683.1': 9,
from main import (login_page, login_manager, admin_required, knowl_reviewer_required, housekeeping, FLASK_LOGIN_VERSION, FLASK_LOGIN_LIMIT) assert admin_required # silence pyflakes assert knowl_reviewer_required # silence pyflakes assert housekeeping # silence pyflakes from lmfdb.app import app from lmfdb.logger import make_logger from distutils.version import StrictVersion # secret key, necessary for sessions, and sessions are # in turn necessary for users to login app.secret_key = '9af"]ßÄ!_°$2ha€42~µ…010' login_manager.init_app(app) app.register_blueprint(login_page, url_prefix="/users") users_logger = make_logger("users", hl=True) if StrictVersion(FLASK_LOGIN_VERSION) < StrictVersion(FLASK_LOGIN_LIMIT): users_logger.warning( "DEPRECATION-WARNING: " "flask-login is older than version {version}. " "Versions older than {version} have different functionality and may " "stop working in the future. " "Consider updating, perhaps through " "`sage -pip install flask-login`.".format(version=FLASK_LOGIN_LIMIT))
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint maass_page = Blueprint("maass", __name__, template_folder='templates') logger = make_logger(maass_page) @maass_page.context_processor def body_class(): return {'body_class': 'maass'} from . import main assert main # silence pyflakes app.register_blueprint(maass_page, url_prefix="/ModularForm/GL2/Q/Maass") # API2 has been disabled for now #from lmfdb.api2.searchers import register_search_function #register_search_function( # "gl2_maass_forms", # "GL2 Maass forms", # "Search over GL2 Maass forms", # auto_search = 'maass_newforms' #)
# -*- coding: utf-8 -*- from lmfdb.logger import make_logger import os from flask import Blueprint, Response, render_template, request, url_for FirstZeros = Blueprint('first L-function zeros', __name__, template_folder="templates") logger = make_logger(FirstZeros) import sqlite3 data_location = os.path.expanduser("~/data/zeros/") @FirstZeros.route("/") def firstzeros(): start = request.args.get('start', None, float) end = request.args.get('end', None, float) limit = request.args.get('limit', 100, int) degree = request.args.get('degree', None, int) # signature_r = request.arts.get("signature_r", None, int) # signature_c = request.arts.get("signature_c", None, int) if limit > 1000: limit = 1000 if limit < 0: limit = 100 # return render_template("first_zeros.html", start=start, end=end, # limit=limit, degree=degree, signature_r=signature_r, # signature_c=signature_c) title = "Search for First Zeros of L-functions" bread = [("L-functions", url_for("l_functions.l_function_top_page")),
# -*- coding: utf-8 -*- # Class created to aid in uploading HMF data from the Magma output data files. # Incomplete, and currently not used for real work. # # In particular this code assumes that all the data for one HMF is in # a single collection, which is no longer the case. from __future__ import print_function from six import text_type from sage.all import QQ, polygen from lmfdb import db from lmfdb.hilbert_modular_forms.hilbert_field import HilbertNumberField from lmfdb.logger import make_logger logger = make_logger("hmf") def construct_full_label(field_label, weight, level_label, label_suffix): if all([w==2 for w in weight]): # Parellel weight 2 weight_label = '' elif all([w==weight[0] for w in weight]): # Parellel weight weight_label = str(weight[0]) + '-' else: # non-parallel weight weight_label = str(weight) + '-' return ''.join([field_label, '-', weight_label, level_label, '-', label_suffix]) class WebHMF(object): """ Class for an Hilbert Modular Newform """
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint smf_page = Blueprint('smf', __name__, template_folder='templates', static_folder='static') smf_logger = make_logger(smf_page) @smf_page.context_processor def body_class(): return {'body_class': 'smf'} import siegel_modular_form assert siegel_modular_form #silence pyflakes app.register_blueprint(smf_page, url_prefix='/ModularForm/GSp/Q')
return "%s.%s%s" % (conductor, iso_class, number) def curve_cremona_label(conductor, iso_class, number): return "%s%s%s" % (conductor, iso_class, number) def class_lmfdb_label(conductor, iso_class): return "%s.%s" % (conductor, iso_class) def class_cremona_label(conductor, iso_class): return "%s%s" % (conductor, iso_class) logger = make_logger("ec") def split_galois_image_code(s): """Each code starts with a prime (1-3 digits but we allow for more) followed by an image code or that prime. This function returns two substrings, the prefix number and the rest. """ p = re.findall(r'\d+', s)[0] return p, s[len(p):] def trim_galois_image_code(s): """Return the image code with the prime prefix removed. """ return split_galois_image_code(s)[1]
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint tensor_products_page = Blueprint( "tensor_products", __name__, template_folder='templates', static_folder="static") tensor_products_logger = make_logger("tensor_products", hl=True) @tensor_products_page.context_processor def body_class(): return {'body_class': 'tensor_products'} import main assert main #silence pyflakes app.register_blueprint(tensor_products_page, url_prefix="/TensorProducts")
import flask from mpmath import nstr, inf from sage.all import floor, log from lmfdb.logger import make_logger from flask import render_template, request, url_for ZetaZeros = flask.Blueprint("zeta zeros", __name__, template_folder="templates") logger = make_logger(ZetaZeros) from platt_zeros import zeros_starting_at_N, zeros_starting_at_t @ZetaZeros.route("/") def zetazeros(): N = request.args.get("N", None, int) t = request.args.get("t", 0, float) limit = request.args.get("limit", 100, int) if limit > 1000: return list_zeros(N=N, t=t, limit=limit) else: title = "Zeros of $\zeta(s)$" bread = [("L-functions", url_for("l_functions.l_function_top_page")), ('Zeros of $\zeta(s)$', ' ')] learnmore = [("Completeness of this data",url_for(".extent") ),("How data was computed", url_for(".howcomputed"))] return render_template('zeta.html', N=N, t=t, limit=limit, title=title, bread=bread, learnmore=learnmore) @ZetaZeros.route("/Extent") def extent (): t = 'Extent of Data for Riemann Zeta Zeros' bread = [("L-functions", url_for("l_functions.l_function_top_page")),
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint hmf_page = Blueprint("hmf", __name__, template_folder='templates', static_folder="static") hmf_logger = make_logger(hmf_page) @hmf_page.context_processor def body_class(): return {'body_class': 'hmf'} import hilbert_modular_form assert hilbert_modular_form app.register_blueprint(hmf_page, url_prefix="/ModularForm/GL2/TotallyReal")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint belyi_page = Blueprint("belyi", __name__, template_folder='templates', static_folder="static") belyi_logger = make_logger(belyi_page) @belyi_page.context_processor def body_class(): return {'body_class': 'belyi'} import main assert main # silence pyflakes app.register_blueprint(belyi_page, url_prefix="/Belyi")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint lattice_page = Blueprint("lattice", __name__, template_folder='templates', static_folder="static") lattice_logger = make_logger(lattice_page) @lattice_page.context_processor def body_class(): return {'body_class': 'lattice'} import main assert main app.register_blueprint(lattice_page, url_prefix="/Lattice")
# -*- coding: utf-8 -*- from __future__ import absolute_import from seminars.app import app from lmfdb.logger import make_logger from flask import Blueprint create_page = Blueprint("create", __name__, template_folder='templates', static_folder="static") create = create_page create_logger = make_logger(create_page) from . import main assert main # silence pyflakes app.register_blueprint(create_page, url_prefix="/create")
# -*- coding: utf-8 -*- from flask import url_for from lmfdb import db from lmfdb.app import app from lmfdb.utils import comma from lmfdb.logger import make_logger from lmfdb.number_fields.web_number_field import nf_display_knowl from sage.misc.cachefunc import cached_method def field_sort_key(F): dsdn = F.split(".") return (int(dsdn[0]), int(dsdn[2])) # by degree then discriminant logger = make_logger("hmf") the_HMFstats = None def get_counts(): global the_HMFstats if the_HMFstats is None: the_HMFstats = HMFstats() return the_HMFstats.counts() def get_stats(d=None): global the_HMFstats if the_HMFstats is None: the_HMFstats = HMFstats() return the_HMFstats.stats(d) def hmf_summary(): counts = get_stats().counts()
# -*- coding: utf-8 -*- from lmfdb import db from lmfdb.app import app from lmfdb.utils import comma from lmfdb.logger import make_logger from sage.misc.cachefunc import cached_method logger = make_logger("rep_galois_modls") the_rep_galois_modlstats = None def get_stats(): global the_rep_galois_modlstats if the_rep_galois_modlstats is None: the_rep_galois_modlstats = rep_galois_modlstats() return the_rep_galois_modlstats def rep_galois_modl_summary(): counts = get_stats().counts() return r"<p>The database currently contains %s <a title='mod ℓ Galois representation'[rep_galois_modl.definition]' knowl='rep_galois_modl.definition' kwargs=''>mod ℓ Galois representations</a>.</p>" % ( str(counts['nrep_galois_modl_c'])) @app.context_processor def ctx_rep_galois_modl_summary(): return {'rep_galois_modl_summary': rep_galois_modl_summary} class rep_galois_modlstats(object):
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint l_function_page = Blueprint("l_functions", __name__, template_folder='templates', static_folder="static") logger = make_logger("LF") @l_function_page.context_processor def body_class(): return {'body_class': 'l_functions'} import main assert main # silence pyflakes app.register_blueprint(l_function_page, url_prefix="/L")
# -*- coding: utf-8 -*- from lmfdb import db from lmfdb.logger import make_logger from lmfdb.number_fields.web_number_field import nf_display_knowl, field_pretty from lmfdb.elliptic_curves.web_ec import split_lmfdb_label from lmfdb.nfutils.psort import primes_iter, ideal_from_label, ideal_label from lmfdb.utils import web_latex, names_and_urls from lmfdb.lfunctions.LfunctionDatabase import (get_instances_by_Lhash, get_instances_by_trace_hash, get_lfunction_by_url) from flask import url_for from sage.all import QQ, PolynomialRing, NumberField logger = make_logger("bmf") class WebBMF(object): """ Class for an Bianchi Newform """ def __init__(self, dbdata): """Arguments: - dbdata: the data from the database dbdata is expected to be a database entry from which the class is initialised. """ logger.debug("Constructing an instance of WebBMF class from database") self.__dict__.update(dbdata) # All other fields are handled here
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint crystals_page = Blueprint("crystals", __name__, template_folder='templates', static_folder="static") logger = make_logger(crystals_page) @crystals_page.context_processor def body_class(): return {'body_class': 'Crystals'} import main assert main # silence pyflakes app.register_blueprint(crystals_page, url_prefix="/Crystals")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint motive_page = Blueprint("motive", __name__, template_folder='templates', static_folder="static") motive_logger = make_logger(motive_page) @motive_page.context_processor def body_class(): return {'body_class': 'motive'} import main assert main # silence pyflakes app.register_blueprint(motive_page, url_prefix="/Motive")
import flask from mpmath import nstr, inf from sage.all import floor, log from lmfdb.logger import make_logger from flask import render_template, request, url_for ZetaZeros = flask.Blueprint("zeta zeros", __name__, template_folder="templates") logger = make_logger(ZetaZeros) from platt_zeros import zeros_starting_at_N, zeros_starting_at_t credit_string = "David Platt" def learnmore_list(): return [('Completeness of the data', url_for(".completeness")), ('Source of the data', url_for(".source")), ('Reliability of the data', url_for(".reliability"))] # Return the learnmore list with the matchstring entry removed def learnmore_list_remove(matchstring): return filter(lambda t: t[0].find(matchstring) < 0, learnmore_list()) @ZetaZeros.route("/") def zetazeros(): N = request.args.get("N", None, int) t = request.args.get("t", 0, float)
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint api_page = Blueprint("API", __name__, template_folder='templates', static_folder="static") api_logger = make_logger(api_page) @api_page.context_processor def body_class(): return {'body_class': 'api'} import api assert api # silence pyflakes app.register_blueprint(api_page, url_prefix="/api")
# -*- coding: utf-8 -*- from lmfdb.logger import make_logger import os from flask import Blueprint, Response, render_template, request, url_for FirstZeros = Blueprint('first L-function zeros', __name__, template_folder="templates") logger = make_logger(FirstZeros) import sqlite3 data_location = os.path.expanduser("~/data/zeros/") @FirstZeros.route("/") def firstzeros(): start = request.args.get('start', None, float) end = request.args.get('end', None, float) limit = request.args.get('limit', 100, int) degree = request.args.get('degree', None, int) # signature_r = request.arts.get("signature_r", None, int) # signature_c = request.arts.get("signature_c", None, int) if limit > 1000: limit = 1000 if limit < 0: limit = 100 # return render_template("first_zeros.html", start=start, end=end, # limit=limit, degree=degree, signature_r=signature_r, # signature_c=signature_c)
# -*- coding: utf-8 -*- from __future__ import absolute_import from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint from lmfdb.api2.searchers import register_search_function nf_page = Blueprint("number_fields", __name__, template_folder='templates', static_folder="static") nf_logger = make_logger(nf_page) @nf_page.context_processor def body_class(): return {'body_class': 'nf'} from . import number_field assert number_field app.register_blueprint(nf_page, url_prefix="/NumberField") register_search_function("number_fields", "Global number fields", "Search over global number fields", auto_search='nf_fields')
# -*- coding: utf-8 -*- from __future__ import absolute_import from beantheory.app import app from lmfdb.logger import make_logger from flask import Blueprint knowledge_page = Blueprint("knowledge", __name__, template_folder='templates') logger = make_logger(knowledge_page) from . import main assert main app.register_blueprint(knowledge_page, url_prefix="/knowledge")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint abvar_page = Blueprint("abvar", __name__, template_folder="templates", static_folder="static") abvar_logger = make_logger(abvar_page) @abvar_page.context_processor def body_class(): return {"body_class": "abvar"} app.register_blueprint(abvar_page, url_prefix="/Variety/Abelian") # API2 has been disabled for now #from lmfdb.api2.searchers import register_search_function #register_search_function( # "abvar", # "Abelian varieties", # "Search over abelian varieties", # auto_search="av_fqisog", # inv=["av", "av_fqisog"], #)
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint from lmfdb.api2.searchers import register_search_function local_fields_page = Blueprint("local_fields", __name__, template_folder='templates', static_folder="static") logger = make_logger(local_fields_page) @local_fields_page.context_processor def body_class(): return {'body_class': 'local_fields'} import main assert main app.register_blueprint(local_fields_page, url_prefix="/LocalNumberField") register_search_function("local_fields", "Local number fields", "Search over local number fields", auto_search='lf_fields')
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint tensor_products_page = Blueprint("tensor_products", __name__, template_folder='templates', static_folder="static") tensor_products_logger = make_logger("tensor_products", hl=True) @tensor_products_page.context_processor def body_class(): return {'body_class': 'tensor_products'} import main assert main #silence pyflakes app.register_blueprint(tensor_products_page, url_prefix="/TensorProducts")
from flask import url_for from collections import defaultdict from sage.all import (gcd, ZZ, Rational, Integers, cached_method, euler_phi, latex) from sage.databases.cremona import cremona_letter_code from sage.misc.lazy_attribute import lazy_attribute from lmfdb import db from lmfdb.utils import prop_int_pretty from lmfdb.utils.utilities import num2letters from lmfdb.logger import make_logger from lmfdb.number_fields.web_number_field import WebNumberField, formatfield, nf_display_knowl from lmfdb.characters.TinyConrey import (ConreyCharacter, kronecker_symbol, symbol_numerator, PariConreyGroup, get_sage_genvalues) from lmfdb.characters.utils import url_character, complex2str from lmfdb.groups.abstract.main import abstract_group_display_knowl logger = make_logger("DC") def parity_string(n): return "odd" if n == -1 else "even" def bool_string(b): return "yes" if b else "no" ############################################################################# ### ### Class for Web objects ### ############################################################################# class WebCharObject(object): """ class for all characters and character groups """
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint bmf_page = Blueprint("bmf", __name__, template_folder='templates', static_folder="static") bmf_logger = make_logger(bmf_page) @bmf_page.context_processor def body_class(): return {'body_class': 'bmf'} from . import bianchi_modular_form assert bianchi_modular_form app.register_blueprint(bmf_page, url_prefix="/ModularForm/GL2/ImaginaryQuadratic")
# -*- coding: utf-8 -*- from __future__ import absolute_import from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint abvarfq_page = Blueprint("abvarfq", __name__, template_folder="templates", static_folder="static") abvarfq_logger = make_logger(abvarfq_page) @abvarfq_page.context_processor def body_class(): return {"body_class": "abvarfq"} from . import main assert main app.register_blueprint(abvarfq_page, url_prefix="/Variety/Abelian/Fq")
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.utils import comma from lmfdb.logger import make_logger from lmfdb import db logger = make_logger("hecke_algebras") def hecke_algebras_summary(): heckestats = db.hecke_algebras.stats hecke_knowl = '<a knowl="hecke_algebra.definition">Hecke algebras</a>' level_knowl = '<a knowl="cmf.level">level</a>' weight_knowl = '<a knowl="cmf.weight">weight</a>' gamma0_knowl = '<a knowl="group.sl2z.subgroup.gamma0n">$\Gamma_0$</a>' level_data = heckestats.get_oldstat('level') number = level_data['total'] max_level = level_data['max'] weight_data = heckestats.get_oldstat('weight') max_weight = weight_data['max'] return ''.join([r'The database currently contains {} '.format(comma(number)), hecke_knowl,'. The largest ', level_knowl, ' for ' , gamma0_knowl , ' is {}, '.format(comma(max_level)), 'the largest ', weight_knowl, ' is {}.'.format(comma(max_weight))]) @app.context_processor def ctx_hecke_algebras_summary(): return {'hecke_algebras_summary': hecke_algebras_summary}
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint modlmf_page = Blueprint("modlmf", __name__, template_folder='templates', static_folder="static") modlmf_logger = make_logger(modlmf_page) @modlmf_page.context_processor def body_class(): return {'body_class': 'modlmf'} from . import main assert main app.register_blueprint(modlmf_page, url_prefix="/ModularForm/GL2/ModL")
from sage.rings.all import PolynomialRing, ZZ from lmfdb import db from lmfdb.app import app from lmfdb.logger import make_logger from lmfdb.utils import ( to_dict, parse_ints, parse_string_start, parse_nf_string, parse_galgrp, parse_subset, parse_submultiset, parse_bool, parse_bool_unknown, search_wrap) from . import abvarfq_page from .search_parsing import parse_newton_polygon from .isog_class import validate_label, AbvarFq_isoclass from .stats import AbvarFqStats logger = make_logger("abvarfq") ######################### # Top level ######################### def get_bread(*breads): bc = [('Abelian Varieties', url_for(".abelian_varieties")), ('Fq', url_for(".abelian_varieties"))] map(bc.append, breads) return bc abvarfq_credit = 'Taylor Dupuy, Kiran Kedlaya, David Roe, Christelle Vincent' @app.route("/EllipticCurves/Fq") def ECFq_redirect():
4: 5 }, 7: { 1: 343, 2: 343, 3: 7 }, } maxgen = {1: 500, 2: 211, 3: 25} if p < 10: return maxspec[p][g] else: return maxgen[g] logger = make_logger("abvarfq") ######################### # Label manipulation ######################### def validate_label(label): parts = label.split(".") if len(parts) != 3: raise ValueError( "it must be of the form g.q.iso, with g a dimension and q a prime power" ) g, q, iso = parts try: g = int(g)
# -*- coding: utf-8 -*- from lmfdb import db from lmfdb.logger import make_logger from lmfdb.number_fields.web_number_field import nf_display_knowl, field_pretty from lmfdb.elliptic_curves.web_ec import split_lmfdb_label from lmfdb.nfutils.psort import primes_iter, ideal_from_label, ideal_label from lmfdb.utils import web_latex, names_and_urls, prop_int_pretty from lmfdb.lfunctions.LfunctionDatabase import ( get_lfunction_by_url, get_instances_by_Lhash_and_trace_hash) from flask import url_for from sage.all import QQ, PolynomialRing, NumberField logger = make_logger("bmf") # Labels of BMFs which have no elliptic curve but are not twists of # base change. Those which have no curve but are twists of base # change are detectable automatically in the code below, but these are # not. Up to Galois conjugacy and quadratic twist there are only four # of these known; each is associated to the Jacobian of a genus 2 # curve over the base field; these curves were found by Ciaran # Schembri. At some point we will want to list these abelian surfaces # as friends when there is no curve. # TO (after adding 31 more for 2.0.43.1): make this list into a table, # OR add a column to the bmf_forms table to indicate whether or not a # curve exists (which could be because we have not foud one, but is # normally because there really is not curve). bmfs_with_no_curve = [ '2.0.4.1-34225.7-b', '2.0.4.1-34225.7-a', '2.0.4.1-34225.3-b', '2.0.4.1-34225.3-a', '2.0.3.1-67081.3-a', '2.0.3.1-67081.3-b',
# -*- coding: utf-8 -*- from lmfdb.app import app from lmfdb.logger import make_logger from flask import Blueprint from lmfdb.api2.searchers import register_search_function higher_genus_w_automorphisms_page = Blueprint("higher_genus_w_automorphisms", __name__, template_folder='templates', static_folder="static") logger = make_logger(higher_genus_w_automorphisms_page) @higher_genus_w_automorphisms_page.context_processor def body_class(): return {'body_class': 'higher_genus_w_automorphisms'} import main assert main # silence pyflakes app.register_blueprint(higher_genus_w_automorphisms_page, url_prefix="/HigherGenus/C/Aut") register_search_function( "group_actions_higher_genus_curves", "Group actions on higher genus curves", "Search over group actions on higher genus curves", auto_search = 'hgcwa_passports' )
# / modular_forms/__init__.py import flask from lmfdb.logger import make_logger from lmfdb.app import app MF_TOP = "Modular Forms" MF = "mf" mf = flask.Blueprint(MF, __name__, template_folder="views/templates", static_folder="views/static") mf_logger = make_logger(mf) import maass_forms assert maass_forms import views assert views app.register_blueprint(mf, url_prefix="/ModularForm/") app.register_blueprint(mf, url_prefix="/AutomorphicForm/") app.register_blueprint(maass_forms.maassf, url_prefix="/ModularForm/Maass") app.register_blueprint(maass_forms.maass_waveforms.mwf, url_prefix="/ModularForm/GL2/Q/Maass") app.register_blueprint(maass_forms.picard.mwfp, url_prefix="/ModularForm/GL2/C/Maass")