def insert_into_db(self):
r"""
Insert a dictionary of data for self into the database collection
WebNewforms.files
"""
wmf_logger.debug("inserting self into db! name={0}".format(self._name))
C = connect_to_modularforms_db('WebNewforms.files')
fs = get_files_from_gridfs('WebNewforms')
s = {'name':self._name,'version':float(self._version)}
rec = C.find_one(s)
if rec:
id = rec.get('_id')
else:
id = None
if id<>None:
wmf_logger.debug("Removing self from db with id={0}".format(id))
fs.delete(id)
fname = "webnewform-{0:0>5}-{1:0>3}-{2:0>3}-{3}".format(self._N,self._k,self._chi,self._label)
d = self.to_dict()
d.pop('_ap',None)
d.pop('_character',None)
d.pop('_as_factor',None)
id = fs.put(dumps(d),filename=fname,N=int(self._N),k=int(self._k),chi=int(self._chi),label=self._label,name=self._name,version=float(self._version))
wmf_logger.debug("inserted :{0}".format(id))
def _get_aps(self, prec=-1):
r"""
Get aps from database if they exist.
"""
ap_files = connect_to_modularforms_db('ap.files')
key = {'k': int(self._k), 'N': int(self._N), 'cchi': int(self._chi)}
key['prec'] = {"$gt": int(prec - 1)}
ap_from_db = ap_files.find(key).sort("prec")
wmf_logger.debug("finds={0}".format(ap_from_db))
wmf_logger.debug("finds.count()={0}".format(ap_from_db.count()))
fs = get_files_from_gridfs('ap')
aplist = {}
for i in range(len(self.labels())):
aplist[self.labels()[i]]={}
for rec in ap_from_db:
wmf_logger.debug("rec={0}".format(rec))
ni = rec.get('newform')
if ni is None:
for a in self.labels():
aplist[a][prec]=None
return aplist
a = self.labels()[ni]
cur_prec = rec['prec']
if aplist.get(a,{}).get(cur_prec,None) is None:
aplist[a][prec]=loads(fs.get(rec['_id']).read())
if cur_prec > prec and prec>0: # We are happy with these coefficients.
return aplist
return aplist
def as_factor(self):
r"""
Return self as a newform factor
"""
if self._as_factor is None:
C = connect_to_modularforms_db('Newform_factors.files')
s = {'N':int(self.level()),'k':int(self.weight()),
'cchi':int(self.chi()),'newform':int(self.newform_number())}
res = C.find_one(s)
print res
if not res is None:
fid = res['_id']
fs = get_files_from_gridfs('Newform_factors')
self._as_factor = loads(fs.get(fid).read())
if self._as_factor is None:
raise ValueError,"Newform matching {0} can not be found".format(s)
return self._as_factor
def get_from_db(self):
r"""
Fetch dictionary data from the database.
"""
db = connect_to_modularforms_db('WebModformspace.files')
s = {'name':self._name,'version':emf_version}
wmf_logger.debug("Looking in DB for rec={0}".format(s))
f = db.find_one(s)
wmf_logger.debug("Found rec={0}".format(f))
if f<>None:
id = f.get('_id')
fs = get_files_from_gridfs('WebModformspace')
f = fs.get(id)
wmf_logger.debug("Getting rec={0}".format(f))
d = loads(f.read())
return d
return {}
def get_modular_symbols(self):
r"""
Get Modular Symbols from database they exist.
"""
if not self._modular_symbols is None:
return
modular_symbols = connect_to_modularforms_db('Modular_symbols.files')
key = {'k': int(self._k), 'N': int(self._N), 'cchi': int(self._chi)}
modular_symbols_from_db = modular_symbols.find_one(key)
wmf_logger.debug("found ms={0}".format(modular_symbols_from_db))
if modular_symbols_from_db is None:
ms = None
else:
id = modular_symbols_from_db['_id']
fs = get_files_from_gridfs('Modular_symbols')
ms = loads(fs.get(id).read())
self._id = id
self._modular_symbols = ms
def get_atkin_lehner_eigenvalues(self):
r"""
Get the Atkin-Lehner eigenvalues from database if they exist.
"""
if not ((self.character().is_trivial() or self.character().order() == 2) and not self._atkin_lehner_eigenvalues is None):
return None
C = connect_to_modularforms_db('Atkin-Lehner.files')
fs = get_files_from_gridfs('Atkin-Lehner')
s = {'N':int(self.level()),'k':int(self.weight()),
'cchi':int(self.chi()),'newform':int(self.newform_number())}
res = C.find_one(s)
self._atkin_lehner_eigenvalues = {}
if not res is None:
alid = res['_id']
al = loads(fs.get(alid).read())
for d in prime_divisors(self.level()):
self._atkin_lehner_eigenvalues[d] = 1 if al[d]=='+' else -1
else: # We compute them
A = self.as_factor()
for p in prime_divisors(self.level()):
self._atkin_lehner_eigenvalues[p]= int(A.atkin_lehner_operator(p).matrix()[0,0])
def get_newform_factors(self):
r"""
Get New form factors from database they exist.
"""
if not self._newforms is None and self._newforms == []:
return
factors = connect_to_modularforms_db('Newform_factors.files')
key = {'k': int(self._k), 'N': int(self._N), 'cchi': int(self._chi),}
factors_from_db = factors.find(key).sort('newform',int(1))
wmf_logger.debug("found factors={0}".format(factors_from_db))
self._newforms = {}
if factors_from_db.count()==0:
raise ValueError,"Space is not in database!"
else:
facts = []
self._labels = []
fs = get_files_from_gridfs('Newform_factors')
for rec in factors_from_db:
factor = loads(fs.get(rec['_id']).read())
label = orbit_label(rec['newform'])
self._galois_orbits_labels.append(label)
self._newforms[label] = factor
def insert_into_db(self):
r"""
Insert a dictionary of data for self into the collection WebModularforms.files
"""
wmf_logger.debug("inserting self into db! name={0}".format(self._name))
db = connect_to_modularforms_db('WebModformspace.files')
fs = get_files_from_gridfs('WebModformspace')
s = {'name':self._name,'version':emf_version}
rec = db.find_one(s)
if rec:
id = rec.get('_id')
else:
id = None
if id<>None:
wmf_logger.debug("Removing self from db with id={0}".format(id))
fs.delete(id)
fname = "webmodformspace-{0:0>5}-{1:0>3}-{2:0>3}".format(self._N,self._k,self._chi)
d = self.to_dict()
d.pop('_ap',None) # Since the ap's are already in the database we don't need them here
id = fs.put(dumps(d),filename=fname,N=int(self._N),k=int(self._k),chi=int(self._chi),name=self._name,version=emf_version)
wmf_logger.debug("inserted :{0}".format(id))
