def __init__(self, dirname):
self.dirname = dirname
self._load_libraries()
logger.info('Found %d libraries underneath %r.' %
(len(self.libraries), self.dirname))
AppEditor.__init__(self)
AppVisualization.__init__(self)
AppQR.__init__(self)
AppSolver.__init__(self)
AppInteractive.__init__(self)
AppSolver2.__init__(self)
AppEditorFancyGeneric.__init__(self)
WebAppImages.__init__(self)
# name -> dict(desc: )
self.views = {}
self.exceptions = []
self.add_model_view('syntax', 'Simple display')
self.add_model_view('edit_fancy', 'Fancy editor')
self.add_model_view('edit', 'Simple editor for IE')
self.add_model_view('ndp_graph', 'NDP Graph representation')
self.add_model_view('ndp_repr', 'NDP Text representation')
self.add_model_view('dp_graph', 'DP graph representation')
self.add_model_view('dp_tree', 'DP tree representation')
self.add_model_view('images', 'other image representations')
self.add_model_view('solver', 'Simple solver')
def view_new_model_generic(self, request, spec):
widget_name = self.get_widget_name(request, spec)
logger.info('New : %r' % widget_name)
library = self.get_current_library_name(request)
basename = '%s.%s' % (widget_name, spec.extension)
l = self.get_library(request)
url_edit = ('/libraries/%s/%s/%s/views/edit_fancy/' %
(library, spec.url_part, widget_name))
if l.file_exists(basename):
error = 'File %r already exists.' % basename
template = 'editor_fancy/error_model_exists_generic.jinja2'
params = {'error': error, 'url_edit': url_edit,
'widget_name': widget_name}
return render_to_response(template, params, request=request)
else:
path = self.libraries[library]['path']
source = spec.minimal_source_code
filename = os.path.join(path, 'created', basename)
d = os.path.dirname(filename)
if not os.path.exists(d):
os.makedirs(d)
logger.info('Writing to file %r.' % filename)
with open(filename, 'w') as f:
f.write(source)
l._update_file(filename)
raise HTTPFound(url_edit)
def _write_generic(self, basename, data):
d = self._get_file_data(basename)
realpath = d["realpath"]
logger.info("writing to %r" % realpath)
with open(realpath, "w") as f:
f.write(data)
# reload
self._update_file(realpath)
def eval_assert_empty(r, context):
from .eval_constant_imp import eval_constant
assert isinstance(r, CDP.AssertEmpty)
v = eval_constant(r.value, context)
seq = get_sequence(v)
check = len(seq) == 0
if check:
logger.info(v.__repr__())
return passed_value()
msg = 'Assertion assert_nonempty() failed.'
raise_desc(DPUserAssertion, msg, v=v)
def render(library, docname, data, realpath, out_dir, generate_pdf):
out = os.path.join(out_dir, docname + ".html")
html_contents = render_complete(
library=library, s=data, raise_errors=True, realpath=realpath, generate_pdf=generate_pdf
)
doc = get_minimal_document(html_contents, add_markdown_css=True)
d = os.path.dirname(out)
if not os.path.exists(d):
os.makedirs(d)
with open(out, "w") as f:
f.write(doc)
logger.info("Written %s " % out)
def go(self):
options = self.get_options()
dirname = options.dir
if dirname is None:
package = dir_from_package_name('mcdp_data')
libraries = os.path.join(package, 'libraries')
msg = ('Option "-d" not passed, so I will open the default libraries '
'shipped with PyMCDP. These might not be writable depending on your setup.')
logger.info(msg)
dirname = libraries
wa = WebApp(dirname)
msg = """Welcome to PyMCDP!
To access the interface, open your browser at the address
http://127.0.0.1:%s/
Use Chrome, Firefox, or Opera - Internet Explorer is not supported.
""" % options.port
if options.delete_cache:
logger.info('Deleting cache...')
wa._refresh_library(None)
logger.info(msg)
wa.serve(port=options.port)
def find_pickling_error(obj, protocol=pickle.HIGHEST_PROTOCOL):
sio = StringIO()
try:
pickle.dumps(obj)
except Exception as e1:
# s1 = traceback.format_exc(e1)
pass
else:
msg = "Strange! I could not reproduce the pickling error " "for the object of class %s" % describe_type(obj)
logger.info(msg)
pickler = MyPickler(sio, protocol)
try:
pickler.dump(obj)
except Exception as e1:
msg = pickler.get_stack_description()
msg += "\n --- Current exception----\n%s" % traceback.format_exc(e1)
msg += "\n --- Old exception----\n%s" % traceback.format_exc(e1)
return msg
else:
msg = "I could not find the exact pickling error."
raise Exception(msg)
def create_movie_from_png_sequence(sequence, out, fps=1.0):
""" Creates an MP4 out of the list of png data """
safe_makedirs(os.path.dirname(out))
tmpdir = mkdtemp()
for i, frame in enumerate(sequence):
fn = os.path.join(tmpdir, '%05d.png' % i)
with open(fn, 'w') as fi:
fi.write(frame)
try:
import procgraph_mplayer # @UnusedImport
except ImportError as e:
logger.error('Cannot use Procgraph to create video.')
logger.error(e)
logger.info('The frames are in the directory %s' % tmpdir)
else:
join_video_29_fixed(output=out, dirname=tmpdir,
pattern='.*.png', fps=fps)
def memo_disk_cache2(cache_file, data, f):
"""
"""
from mocdp import logger
dirname = os.path.dirname(cache_file)
cachedir = os.path.join(dirname)
if not os.path.exists(cachedir):
try:
os.makedirs(cachedir)
except:
if os.path.exists(cachedir):
pass
else:
raise
if os.path.exists(cache_file):
# logger.info('Reading from cache %r.' % cache_file)
try:
res = safe_pickle_load(cache_file)
if data != res["data"]:
logger.info("Stale cache, recomputing.")
else:
return res["result"]
except Exception as e:
logger.error(e)
result = f()
if MCDPConstants.log_cache_writes:
logger.info("Writing to cache %s." % cache_file)
res = dict(data=data, result=result)
safe_pickle_dump(res, cache_file)
return result
def dual01_chain(id_dp, dp):
try:
with primitive_dp_test(id_dp, dp):
print('Starting testing with %r' % id_dp)
# get a chain of resources
F = dp.get_fun_space()
R = dp.get_res_space()
# try to solve
try:
dp.solve(F.witness())
dp.solve_r(R.witness())
except NotSolvableNeedsApprox:
print('NotSolvableNeedsApprox - doing lower bound ')
n = 5
dpL, dpU = get_dp_bounds(dp, nl=n, nu=n)
dual01_chain(id_dp+'_L%s'%n, dpL)
dual01_chain(id_dp+'_U%s'%n, dpU)
return
LF = LowerSets(F)
UR = UpperSets(R)
rchain = R.get_test_chain(n=8)
poset_check_chain(R, rchain)
try:
lfchain = list(map(dp.solve_r, rchain))
for lf in lfchain:
LF.belongs(lf)
except NotSolvableNeedsApprox as e:
print('skipping because %s' % e)
return
try:
poset_check_chain(LF, list(reversed(lfchain)))
except ValueError as e:
msg = 'The results of solve_r() are not a chain.'
raise_wrapped(Exception, e, msg, chain=rchain, lfchain=lfchain)
# now, for each functionality f,
# we know that the corresponding resource should be feasible
for lf, r in zip(lfchain, rchain):
print('')
print('r: %s' % R.format(r))
print('lf = h*(r) = %s' % LF.format(lf))
for f in lf.maximals:
print(' f = %s' % F.format(f))
f_ur = dp.solve(f)
print(' f_ur = h(f) = %s' % UR.format(f_ur))
try:
f_ur.belongs(r)
except NotBelongs as e:
try:
Rcomp.tolerate_numerical_errors = True
f_ur.belongs(r)
logger.info('In this case, there was a numerical error')
logger.info('Rcomp.tolerate_numerical_errors = True solved the problem')
except:
msg = ''
raise_wrapped(AssertionError, e, msg,
lf=lf, r=r, f_ur=f_ur,
r_repr=r.__repr__(),
f_ur_minimals=f_ur.minimals.__repr__())
finally:
Rcomp.tolerate_numerical_errors = False
def do_plots(logger, model_name, plots, outdir, extra_params,
maindir, extra_dirs, use_cache):
data = {}
if '.mcdp' in model_name:
model_name2 = model_name.replace('.mcdp', '')
msg = 'Arguments should be model names, not file names.'
msg += ' Interpreting %r as %r.' % (model_name, model_name2)
logger.warn(msg)
model_name = model_name2
data['model_name'] = model_name
if use_cache:
cache_dir = os.path.join(outdir, '_cached/mcdp_plot_cache')
logger.info('using cache %s' % cache_dir)
else:
cache_dir = None
librarian = Librarian()
for e in extra_dirs:
librarian.find_libraries(e)
library = librarian.get_library_by_dir(maindir)
if cache_dir is not None:
library.use_cache_dir(cache_dir)
assert library.library_name is not None
filename = model_name + '.mcdp'
x = library._get_file_data(filename)
data['s'] = x['data']
data['filename'] = x['realpath']
data['params'] = parse_params(extra_params)
data['library'] = library
d = dict(allplots)
results = []
for p in plots:
# print('plotting %r ' % p)
try:
if p in d:
res = d[p](data)
else:
msg = 'Unknown plot.'
raise_desc(ValueError, msg, plot=p, available=sorted(d.keys()))
except CmdException as e:
mcdp_dev_warning('Add better checks of error.')
logger.error(e)
continue
except Exception as e:
logger.error('While creating %r' % p)
raise
assert isinstance(res, list), res
for r in res:
assert isinstance(r, tuple), r
mime, name, x = r
assert isinstance(x, str), x
ext = mime
base = model_name + '-%s.%s' % (name, ext)
out = os.path.join(outdir, base)
logger.info('Writing to %s' % out)
with open(out, 'w') as f:
f.write(x)
results.append(r)
return results
