def save_mangled(self, name, dir=None):
r"""
Save an object using its standardized name.
INPUT:
- ``self`` -- the current object.
- ``name`` -- string: the file name suffix (without ".obj")
part of the standardized name.
- ``dir`` -- string, optional. The directory where the object
is to be saved. Default is None, meaning the current directory.
OUTPUT:
None.
EFFECT:
A file is created and the object ``self`` is saved into the file.
EXAMPLES:
::
sage: from boolean_cayley_graphs.boolean_function_improved import BooleanFunctionImproved as BFI
sage: a = BFI([0,1,0,0])
sage: d = tmp_dir()
sage: a.save_mangled("a", dir=d)
sage: file_name = BFI.mangled_name("a.sobj", dir=d)
sage: os.path.isfile(file_name)
True
sage: BFI.remove_mangled("a", dir=d)
sage: os.rmdir(d)
"""
save(self, self.__class__.mangled_name(name, dir=dir))
def _create_col_dict_sobj(self, sobj_path=None):
r"""
Create ``sobj`` files containing the number of knots and a dictionary
for the columns of the table.
EXAMPLES::
sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
sage: ki_db._create_col_dict_sobj() # not tested (used on installation)
"""
knot_list = self.knot_list()
knot_column_names = knot_list[0]
link_list = self.link_list()
link_column_names = link_list[0]
column_dict = {}
if not sobj_path:
sobj_path = self._sobj_path
# ----------------------------------------------------------------
# Columns that exist for knots and links
# ----------------------------------------------------------------
for col in knot_column_names:
name = knot_column_names[col]
if not name and col not in [
'knot_atlas_anon', 'knotilus_page_anon'
]:
# not of interest
continue
col_type = KnotInfoColumnTypes.OnlyKnots
if col in link_column_names:
col_type = KnotInfoColumnTypes.KnotsAndLinks
column_dict[col] = [name, col_type]
# ----------------------------------------------------------------
# Columns that exist for links only
# ----------------------------------------------------------------
for col in link_column_names:
name = link_column_names[col]
if not name and col not in [
'knot_atlas_anon', 'knotilus_page_anon'
]:
# not of interest
continue
if col in knot_column_names:
# already used
continue
col_type = KnotInfoColumnTypes.OnlyLinks
column_dict[col] = [name, col_type]
save(column_dict,
'%s/%s' % (sobj_path, self.filename.knots.sobj_column()))
def _subprocess(self, f, dir, args, kwds={}):
"""
Setup and run evaluation of ``f(*args, **kwds)``, storing the
result in the given directory ``dir``.
This method is called by each forked subprocess.
INPUT:
- ``f`` -- a function
- ``dir`` -- name of a directory
- ``args`` -- a tuple with positional arguments for ``f``
- ``kwds`` -- (optional) a dict with keyword arguments for ``f``
TESTS:
The method ``_subprocess`` is really meant to be run only in a
subprocess. It doesn't print not return anything, the output is
saved in pickles. It redirects stdout, so we save and later
restore stdout in order not to break the doctester::
sage: saved_stdout = sys.stdout
sage: F = sage.parallel.use_fork.p_iter_fork(2,3)
sage: F._subprocess(operator.add, tmp_dir(), (1, 2))
sage: sys.stdout = saved_stdout
"""
import os
import sys
try:
from importlib import reload
except ImportError:
from imp import reload
from sage.misc.persist import save
# Make it so all stdout is sent to a file so it can
# be displayed.
out = os.path.join(dir, '%s.out' % os.getpid())
sys.stdout = open(out, 'w')
# Run some commands to tell Sage that its
# pid has changed (forcing a reload of
# misc).
import sage.misc.misc
reload(sage.misc.misc)
# The pexpect interfaces (and objects defined in them) are
# not valid.
if self.reset_interfaces:
sage.interfaces.quit.invalidate_all()
# Now evaluate the function f.
value = f(*args, **kwds)
# And save the result to disk.
sobj = os.path.join(dir, '%s.sobj' % os.getpid())
save(value, sobj, compress=False)
def backup(self):
path = self.path
prec = self.prec
print "Writing to '" + path + ".sobj'."
save(self,path)
if prec != None: save(prec,path+"_prec"+repr(prec))
return self
def __call__(self, *args, **kwds):
key = self.key(*args, **kwds)
h = self._hash(key)
name = '%s_%s.sobj' % (self._prefix, h)
if os.path.exists(name):
key2, val = persist.load(name)
if key == key2:
# We save and test equality of keys to avoid
# the (extremely remote) possibility of a hash
# collision. Correctness is crucial in mathematics.
return val
val = self._func(*args, **kwds)
persist.save((key, val), name)
return val
def _init(self, path):
"""
Create the database from scratch from the PARI files on John Jones's
web page, downloaded (e.g., via wget) to a local directory, which
is specified as path above.
INPUT:
- ``path`` - (default works on William Stein install.)
path must be the path to Jones's Number_Fields directory
http://hobbes.la.asu.edu/Number_Fields These files should have
been downloaded using wget.
EXAMPLES: This is how to create the database from scratch, assuming
that the number fields are in the default directory above: From a
cold start of Sage::
sage: J = JonesDatabase()
sage: J._init() # not tested
...
This takes about 5 seconds.
"""
from sage.misc.misc import sage_makedirs
x = PolynomialRing(RationalField(), 'x').gen()
self.root = {}
self.root[tuple([])] = [x - 1]
if not os.path.exists(path):
raise IOError("Path %s does not exist." % path)
for X in os.listdir(path):
if X[-4:] == "solo":
Z = path + "/" + X
print(X)
for Y in os.listdir(Z):
if Y[-3:] == ".gp":
self._load(Z, Y)
sage_makedirs(JONESDATA)
save(self.root, JONESDATA + "/jones.sobj")
def _init(self, path):
"""
Create the database from scratch from the PARI files on John Jones's
web page, downloaded (e.g., via wget) to a local directory, which
is specified as path above.
INPUT:
- ``path`` - (default works on William Stein install.)
path must be the path to Jones's Number_Fields directory
http://hobbes.la.asu.edu/Number_Fields These files should have
been downloaded using wget.
EXAMPLES: This is how to create the database from scratch, assuming
that the number fields are in the default directory above: From a
cold start of Sage::
sage: J = JonesDatabase()
sage: J._init() # not tested
...
This takes about 5 seconds.
"""
from sage.misc.misc import sage_makedirs
x = PolynomialRing(RationalField(), 'x').gen()
self.root = {}
self.root[tuple([])] = [x - 1]
if not os.path.exists(path):
raise IOError("Path %s does not exist." % path)
for X in os.listdir(path):
if X[-4:] == "solo":
Z = path + "/" + X
print(X)
for Y in os.listdir(Z):
if Y[-3:] == ".gp":
self._load(Z, Y)
sage_makedirs(JONESDATA)
save(self.root, JONESDATA + "/jones.sobj")
def create_filecache(self, force=False):
r"""
Create the internal files containing the database.
INPUT:
- ``force`` -- optional boolean. If set to ``True`` the existing
file-cache is overwritten
EXAMPLES::
sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
sage: ki_db.create_filecache() # optional - database_knotinfo
"""
if not self._feature.is_present():
return
if os.path.isdir(self._sobj_path):
# if it exists then remove it if it belongs to an older version of
# the database or should be reset by the user because it is damaged.
test_version = os.path.join(
self._sobj_path, self.filename.knots.num_knots(self.version()))
if force or not os.path.isfile(test_version):
import shutil
shutil.rmtree(self._sobj_path)
from sage.misc.temporary_file import atomic_dir
with atomic_dir(self._sobj_path) as d:
sobj_path = d.name
num_knots_file = os.path.join(
sobj_path, self.filename.knots.num_knots(self.version()))
knot_list = self.knot_list()
num_knots = len(knot_list) - 1
save(num_knots, num_knots_file)
self._num_knots = num_knots
self._create_col_dict_sobj(sobj_path=sobj_path)
self._create_data_sobj(sobj_path=sobj_path)
return
def backup(self):
print "Writing to `" + self.path + ".sobj'."
save(self,self.path)
if self.prec != None: save(self.prec,self.path+"_prec"+repr(self.prec))
return self
def show(plt=PLT,
comment=None,
folder=os.path.join(TMP_FOLDER, 'matplotlib'),
html_filename='index.html',
verbose=False,
track_caller=True,
sage=False):
"""
Plot to a png file and append <img> in a html file.
"""
if not os.path.isdir(folder):
os.mkdir(folder)
full_html_filename = os.path.join(folder, html_filename)
if not os.path.isfile(full_html_filename):
with open(folder + '/' + html_filename, 'w') as html_file:
html_file.write(HTML_HULL)
full_img_filename = os.path.join(
folder,
str(datetime.datetime.now()).replace(' ', '-').replace('', '') +
'.png')
if sage:
import sage.misc.persist as p
p.save(plt, full_img_filename, axes=False, aspect_ratio=True)
#os.system('open -a Preview /tmp/dom.png')
else:
plt.savefig(full_img_filename)
plt.gcf().clear()
if track_caller:
code = inspect.currentframe().f_back.f_code
caller_filename = code.co_filename
if not os.path.isfile(caller_filename):
track_caller = False
else:
with open(caller_filename) as f:
code_html = highlight(f.read(), PythonLexer(),
HtmlFormatter(linespans='line'))
code_css = HtmlFormatter(
linespans='line').get_style_defs('.highlight')
calling_code_html = os.path.join(
folder,
str(datetime.datetime.now()).replace(' ', '-') + '.html')
with open(calling_code_html, 'w') as html_file:
tmp = HTML_HULL.replace(
'<!--PLACEHOLDER-->', """<p class='p_image'><img src='""" +
full_img_filename + """'/><br/>
<pre>""" + full_img_filename +
("-" + comment if comment else "") + "</pre></p>" +
("caller: <a href='" + calling_code_html + "#line-" +
str(code.co_firstlineno) + "'>" + caller_filename +
"</a>" if track_caller else "") + "<br/>" + code_html
).replace(
'<!--STYLEPLACEHOLDER-->',
code_css + "\n#line-" + str(code.co_firstlineno) +
"{ background-color: #ddff36;} html, body {font-family: Verdana,sans-serif;} a {text-decoration: none; color: hotpink; } a:visited { color: grey; }"
)
html_file.write(tmp)
with open(folder + '/' + html_filename, 'r') as html_file:
html_old = html_file.read()
with open(folder + '/' + html_filename, 'w') as html_file:
html_file.write(
html_old.replace(
'<!--PLACEHOLDER-->', """<!--PLACEHOLDER-->
<p class='p_image'><img src='""" + full_img_filename + """'/><br/>
<pre>""" + full_img_filename +
("-" + comment if comment else "") + "</pre>" +
("caller: <a href='" + calling_code_html + "#line-" +
str(code.co_firstlineno) + "'>" + caller_filename +
"</a>" if track_caller else "") + "</p>").
replace(
'<!--STYLEPLACEHOLDER-->',
'html, body {font-family: Verdana,sans-serif;} a {text-decoration: none; color: hotpink; } a:visited { color: grey; }'
))
if verbose:
print('plot viewable in=', full_html_filename)
def _create_data_sobj(self, sobj_path=None):
r"""
Create ``sobj`` files containing the contents of the whole table.
To each column there is created one file containing a list of
strings giving the entries of the database table.
The length of these lists depends on the type of the corresponding
column. If a column is used in both tables
(``KnotInfoColumnTypes.KnotsAndLinks``) the list of proper links
is appended to the list of knots. In both other cases the lenght
of the list corresponds to the number of listed knots and proper
links respectively.
EXAMPLES::
sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
sage: ki_db._create_data_sobj() # not tested (just used on installation)
"""
knot_list = self.knot_list()
link_list = self.link_list()
len_knots = len(knot_list)
len_links = len(link_list)
row_dict = {}
if not sobj_path:
sobj_path = self._sobj_path
# ----------------------------------------------------------------
# Columns that exist for knots and links
# ----------------------------------------------------------------
column_dict = load('%s/%s' %
(sobj_path, self.filename.knots.sobj_column()))
cols = KnotInfoColumns('ColsTemp', column_dict)
for col in cols:
val_list = []
if col.column_type() != col.types.OnlyLinks:
for i in range(1, len_knots):
if col.name == self._names_column:
row_dict[self._knot_prefix +
knot_list[i][col.name]] = [i - 1, 1]
val_list.append(knot_list[i][col.name])
if col.column_type() != col.types.OnlyKnots:
for i in range(1, len_links):
if col.name == self._names_column:
link_name = link_list[i][col.name]
link_name = link_name.replace('{', '_')
link_name = link_name.replace(',', '_')
link_name = link_name.replace('}', '')
num_comp = int(link_list[i][self._components_column])
row_dict[link_name] = [i + len_knots - 2, num_comp]
val_list.append(link_list[i][col.name])
if val_list:
save(val_list,
'%s/%s' % (sobj_path, self.filename.knots.sobj_data(col)))
save(row_dict, '%s/%s' % (sobj_path, self.filename.knots.sobj_row()))
