def go(): librarian = Librarian() librarian.find_libraries('../..') library = librarian.load_library('droneD_complete_templates') library.use_cache_dir('_cached/drone_unc2') context = library._generate_context_with_hooks() res = {} res['intervals'] = [0, 0.01, 0.1, 1.0, 5.0, 10.0, 50, 100.0, 250, 500, 1000] res['results'] = [] for i, interval_mw in enumerate(res['intervals']): s = get_ndp_code(interval_mw=interval_mw) ndp = parse_ndp(s, context=context) basename = ('drone_unc2_%02d_%s_mw' % (i, interval_mw)).replace('.', '_') fn = os.path.join('generated', 'drone_unc2', basename + '.mcdp') dn = os.path.dirname(fn) if not os.path.exists(dn): os.makedirs(dn) with open(fn, 'w') as f: f.write(s) print('Generated %s' % fn) result = solve_stats(ndp) result['ndp'] = ndp res['results'].append(result) return res
def feat_import5(): """ Warnings in imports. """ data = { 'lib1.mcdplib/model0.mcdp': """ mcdp { provides f [Nat] f <= Nat: 2 } """, 'lib1.mcdplib/model1.mcdp': """ mcdp { a = instance `model0 } """ } d = create_hierarchy(data) librarian = Librarian() librarian.find_libraries(d) lib = librarian.load_library('lib1') context = lib._generate_context_with_hooks() _model2 = lib.load_ndp('model1', context) for w in context.warnings: print w.format_user() assert_equal(len(context.warnings), 1)
def go(): librarian = Librarian() librarian.find_libraries('../..') library = librarian.load_library('droneD_complete_templates') library.use_cache_dir('_cached/drone_unc2') context = library._generate_context_with_hooks() res = {} res['intervals'] = [ 0, 0.01, 0.1, 1.0, 5.0, 10.0, 50, 100.0, 250, 500, 1000 ] res['results'] = [] for i, interval_mw in enumerate(res['intervals']): s = get_ndp_code(interval_mw=interval_mw) ndp = parse_ndp(s, context=context) basename = ('drone_unc2_%02d_%s_mw' % (i, interval_mw)).replace( '.', '_') fn = os.path.join('generated', 'drone_unc2', basename + '.mcdp') dn = os.path.dirname(fn) if not os.path.exists(dn): os.makedirs(dn) with open(fn, 'w') as f: f.write(s) print('Generated %s' % fn) result = solve_stats(ndp) result['ndp'] = ndp res['results'].append(result) return res
def process(s): librarian = Librarian() librarian.find_libraries('../..') library = librarian.load_library('droneD_complete_templates') library.use_cache_dir('_cached/drone_unc1') ndp = library.parse_ndp(s) combinations = { "endurance": (np.linspace(1, 1.5, 10), "hour"), "extra_payload": (100, "g"), "num_missions": (1000, "[]"), "velocity": (1.0, "m/s"), 'extra_power': (0.5, 'W'), } result_like = dict(total_cost="USD", total_mass='kg') dataU = solve_combinations(ndp, combinations, result_like, upper=1, lower=None) dataL = solve_combinations(ndp, combinations, result_like, upper=None, lower=1) return dict(dataL=dataL, dataU=dataU)
def get_test_librarian(): package = dir_from_package_name('mcdp_data') folder = os.path.join(package, 'bundled.mcdp_repo') if not os.path.exists(folder): raise_desc(ValueError, 'Test folders not found.', folder=folder) librarian = Librarian() librarian.find_libraries(folder) libraries = librarian.libraries n = len(libraries) if n <= 1: msg = 'Expected more libraries.' raise_desc(ValueError, msg, folder, libraries=libraries) orig = list(libraries) vname = MCDPConstants.ENV_TEST_LIBRARIES if vname in os.environ: use = os.environ[vname].split(",") logger.debug('environment variable %s = %s' % (vname, use)) logger.info('Because %s is set, I will use only %s instead of %s.' % (vname, use, orig)) for _ in orig: if not _ in use: del libraries[_] else: pass #logger.debug('environment variable %s is unset' % vname) vname2 = MCDPConstants.ENV_TEST_LIBRARIES_EXCLUDE if vname2 in os.environ: exclude = os.environ[vname2].split(',') logger.debug('environment variable %s = %s' % (vname2, exclude)) else: exclude = [] # logger.debug('environment variable %s is unset' % vname2) if exclude: for a in exclude: if not a in libraries: msg = '%s = %s but %r is not a library.' % (vname2, exclude, a) logger.error(msg) else: logger.info('Excluding %s' % vname2) del libraries[a] return librarian
def feat_import4(): data = { 'lib1.mcdplib/model0.mcdp': "mcdp {}", 'lib1.mcdplib/template1.mcdp_template': "template [] mcdp { a = instance `model0 }", 'lib2.mcdplib/template2.mcdp_template': "`lib1.template1", 'lib2.mcdplib/model2.mcdp': "specialize [] `template2", } d = create_hierarchy(data) librarian = Librarian() librarian.find_libraries(d) lib2 = librarian.load_library('lib2') context = lib2._generate_context_with_hooks() _model2 = lib2.load_ndp('model2', context)
def feat_import3(): """ NDP load """ data = { 'lib1.mcdplib/model0.mcdp': "mcdp {}", 'lib1.mcdplib/model1.mcdp': "`model0", 'lib2.mcdplib/model2.mcdp': "`lib1.model1", } d = create_hierarchy(data) librarian = Librarian() librarian.find_libraries(d) lib2 = librarian.load_library('lib2') context = lib2._generate_context_with_hooks() _model2 = lib2.load_ndp('model2', context)
def get_test_library2(libnames): package = dir_from_package_name('mcdp_data') all_libraries = os.path.join(package, 'libraries') librarian = Librarian() librarian.find_libraries(all_libraries) l = MCDPLibrary() for lib in libnames: data = librarian.libraries[lib] path = data['path'] l.add_search_dir(path) l.load_library_hooks.append(librarian.load_library) return l
def __init__(self, app, request): ''' dirnames: list of directories where to find shelves ''' self.app = app self.shelves_all = {} self.request = request self.librarian = Librarian() self.authenticated_userid = request.authenticated_userid # used during auth procedure self.candidate_user = None self.soft_match = None self.next_location = None self.recompute_available()
def go(self): logger.setLevel(logging.DEBUG) options = self.get_options() if not options.contracts: disable_all() params = options.get_extra() if len(params) < 1: raise ValueError("Please specify name.") config_dirs = options.config_dirs.split(":") maindir = options.maindir out_dir = options.out if out_dir is None: out_dir = os.path.join("out", "mcdp_render") if options.cache: cache_dir = os.path.join(out_dir, "_cached", "solve") else: cache_dir = None librarian = Librarian() for e in config_dirs: librarian.find_libraries(e) library = librarian.get_library_by_dir(maindir) if cache_dir is not None: library.use_cache_dir(cache_dir) docs = params if not docs: msg = "At least one argument required." raise_desc(UserError, msg) for docname in docs: basename = docname + "." + MCDPLibrary.ext_doc_md f = library._get_file_data(basename) data = f["data"] realpath = f["realpath"] generate_pdf = options.pdf render(library, docname, data, realpath, out_dir, generate_pdf)
def find_dependencies(config_dirs, maindir, seeds): """ returns res, with res['fd'] ~ FindDependencies """ librarian = Librarian() for e in config_dirs: librarian.find_libraries(e) default_library = librarian.get_library_by_dir(maindir) fd = FindDependencies(default_library) if seeds is None: # add all models for all libraries libnames = list(librarian.get_libraries()) seeds = [] for libname in libnames: library = librarian.load_library(libname) ndps = library.list_spec(SPEC_MODELS) for name in ndps: seeds.append('%s.%s' % (libname, name)) else: pass fd.search(seeds) res = {} res['fd'] = fd return res
def get_test_librarian(): package = dir_from_package_name('mcdp_data') folder = os.path.join(package, 'libraries') if not os.path.exists(folder): raise_desc(ValueError, 'Test folders not found.' , folder=folder) librarian = Librarian() librarian.find_libraries(folder) libraries = librarian.get_libraries() n = len(libraries) if n <= 1: msg = 'Expected more libraries.' raise_desc(ValueError, msg, folder, libraries=libraries) return librarian
def _load_libraries(self): """ Loads libraries in the "self.dirname" dir. """ self.librarian = Librarian() self.librarian.find_libraries(self.dirname) self.libraries = self.librarian.get_libraries() for _short, data in self.libraries.items(): l = data['library'] path = data['path'] cache_dir = os.path.join(path, '_cached/mcdpweb_cache') l.use_cache_dir(cache_dir)
def go(): model_name = 'droneC' queries = [] def add(q): queries.append(q) n = 10 endurance = np.linspace(1, 20, n) payload = np.linspace(5, 50, n) for endurance, payload in zip(endurance, payload): q = { "num_missions": (1000, "[]"), "extra_power": (5, "W"), "extra_payload": (payload, "g"), "endurance": (endurance, "minutes"), } add(q) result_like = dict(total_cost="CHF", total_mass='kg') what_to_plot_res = result_like what_to_plot_fun = dict(extra_payload="g", endurance="minutes") librarian = Librarian() librarian.find_libraries('..') lib = librarian.load_library('droneC_cost_v1') ndp = lib.load_ndp(model_name) data = solve_queries(ndp, queries, result_like) r = Report() plot_all_directions(r, queries=data['queries'], results=data['results'], what_to_plot_res=what_to_plot_res, what_to_plot_fun=what_to_plot_fun) fn = 'out/droneC_c1.html' print('writing to %r' % fn) r.to_html(fn)
def feat_import2(): """ NDP load """ data = { 'lib1.mcdplib/model1.mcdp': "mcdp {}", 'lib2.mcdplib/model2.mcdp': "`lib1.model1", 'lib2.mcdplib/model3.mcdp': """\ mcdp { a = instance `lib1.model1 } """ } d = create_hierarchy(data) librarian = Librarian() librarian.find_libraries(d) lib1 = librarian.load_library('lib1') _model1 = lib1.load_ndp('model1', context=Context()) lib2 = librarian.load_library('lib2') context = lib1._generate_context_with_hooks() _model2 = lib2.load_ndp('model2', context) _model3 = lib2.load_ndp('model3', context)
def find_dependencies(config_dirs, maindir, seeds): """ returns res, with res['fd'] ~ FindDependencies """ librarian = Librarian() for e in config_dirs: librarian.find_libraries(e) default_library = librarian.get_library_by_dir(maindir) fd = FindDependencies(default_library) if seeds is None: # add all models for all libraries libnames = list(librarian.get_libraries()) seeds = [] for libname in libnames: library = librarian.load_library(libname) ndps = library.list_ndps() for name in ndps: seeds.append('%s.%s' % (libname, name)) else: pass fd.search(seeds) res = {} res['fd'] = fd return res
def process(s): librarian = Librarian() librarian.find_libraries('../..') library = librarian.load_library('droneD_complete_templates') library.use_cache_dir('_cached/drone_unc1') ndp = library.parse_ndp(s) combinations = { "endurance": (np.linspace(1, 1.5, 10), "hour"), "extra_payload": (100, "g"), "num_missions": ( 1000, "[]"), "velocity": (1.0, "m/s"), 'extra_power': (0.5, 'W'), } result_like = dict(total_cost="USD", total_mass='kg') dataU = solve_combinations(ndp, combinations, result_like, upper=1, lower=None) dataL = solve_combinations(ndp, combinations, result_like, upper=None, lower=1) return dict(dataL=dataL, dataU=dataU)
def do_plots(logger, model_name, plots, outdir, extra_params, maindir, extra_dirs, use_cache): 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 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 is_ndp = library.file_exists(model_name + '.mcdp') is_poset = library.file_exists(model_name + '.mcdp_poset') if is_ndp: results = do_plots_ndp(model_name, library, plots, extra_params) elif is_poset: results = do_plots_poset(model_name, library, plots) else: msg = 'Cannot find anything corresponding to %r.' % model_name raise_desc(ValueError, msg) return write_results(results, model_name, outdir)
def feat_import2(): """ NDP load """ data = { 'lib1.mcdplib/model1.mcdp': "mcdp {}", 'lib2.mcdplib/model2.mcdp': "`lib1.model1", 'lib2.mcdplib/model3.mcdp': """\ mcdp { a = new lib1.model1 } """ } d = create_hierarchy(data) librarian = Librarian() librarian.find_libraries(d) lib1 = librarian.load_library('lib1') _model1 = lib1.load_ndp('model1', context=Context()) lib2 = librarian.load_library('lib2') context = lib1._generate_context_with_hooks() _model2 = lib2.load_ndp('model2', context) _model3 = lib2.load_ndp('model3', context)
def go(algo): librarian = Librarian() librarian.find_libraries('../..') library = librarian.load_library('droneD_complete_templates') library.use_cache_dir('_cached/drone_unc3') context = library._generate_context_with_hooks() res = {} res['n'] = [ 1, 5, 10, 15, 25, 50, 61, 75, 92, 100, 125, 150, 160, 175, 182, 200, 300, 400, 500, 600, 1000, 1500 ] # res['n'] = [1, 5, 10, 15, 25, 50, 61, 100] # res['n'] = [3000] res['results'] = [] for n in res['n']: ndp = create_ndp(context) result = solve_stats(ndp=ndp, n=n, algo=algo) result['ndp'] = ndp res['results'].append(result) return res
def feat_import1(): """ Poset load """ data = { 'lib1.mcdplib/poset1.mcdp_poset': "product(mass:g, energy:J)", 'lib2.mcdplib/poset2.mcdp_poset': "`lib1.poset1" } d = create_hierarchy(data) librarian = Librarian() librarian.find_libraries(d) libraries = librarian.get_libraries() assert 'lib1' in libraries assert 'lib2' in libraries assert 'path' in libraries['lib1'] assert 'library' in libraries['lib1'] lib1 = librarian.load_library('lib1') context = lib1._generate_context_with_hooks() _poset1 = lib1.load_poset('poset1', context) lib2 = librarian.load_library('lib2') _poset2 = lib2.load_poset('poset2', context)
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
class WebApp(AppEditor, AppVisualization, AppQR, AppSolver, AppInteractive, AppSolver2, AppEditorFancyGeneric, WebAppImages): 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 add_model_view(self, name, desc): self.views[name] = dict(desc=desc, order=len(self.views)) def _get_views(self): return sorted(self.views, key=lambda _:self.views[_]['order']) def get_current_library_name(self, request): library_name = str(request.matchdict['library']) # unicod return library_name def get_library(self, request): library_name = self.get_current_library_name(request) if not library_name in self.libraries: msg = 'Could not find library %r.' % library_name raise_desc(ValueError, msg, available=self.libraries) return self.libraries[library_name]['library'] def list_of_models(self, request): l = self.get_library(request) return l.get_models() @contract(returns='list(str)') def list_libraries(self): """ Returns the list of libraries """ return sorted(self.libraries) def view_index(self, request): # @UnusedVariable d = {} d['version'] = lambda: mocdp.__version__ return d def view_list(self, request): res = {} res['navigation'] = self.get_navigation_links(request) res.update(self.get_jinja_hooks(request)) return res def view_list_libraries(self, request): # @UnusedVariable libraries = self.list_libraries() return {'libraries': sorted(libraries)} def _refresh_library(self, _request): # nuclear option self._load_libraries() for l in [_['library'] for _ in self.libraries.values()]: l.delete_cache() from mcdp_report.gdc import get_images assert hasattr(get_images, 'cache') # in case it changes later get_images.cache = {} def _load_libraries(self): """ Loads libraries in the "self.dirname" dir. """ self.librarian = Librarian() self.librarian.find_libraries(self.dirname) self.libraries = self.librarian.get_libraries() for _short, data in self.libraries.items(): l = data['library'] path = data['path'] cache_dir = os.path.join(path, '_cached/mcdpweb_cache') l.use_cache_dir(cache_dir) def view_refresh_library(self, request): """ Refreshes the current library (if external files have changed) then reloads the current url. """ self._refresh_library(request) raise HTTPFound(request.referrer) def view_not_found(self, request): request.response.status = 404 url = request.url referrer = request.referrer self.exceptions.append('Path not found.\n url: %s\n ref: %s' % (url, referrer)) return {'url': url, 'referrer': referrer} def view_exceptions_occurred(self, request): # @UnusedVariable exceptions = [] for e in self.exceptions: u = unicode(e, 'utf-8') exceptions.append(u) return {'exceptions': exceptions} def view_exception(self, exc, request): request.response.status = 500 # Internal Server Error import traceback compact = (DPSemanticError, DPSyntaxError) if isinstance(exc, compact): s = exc.__str__() else: s = traceback.format_exc(exc) url = request.url referrer = request.referrer n = 'Error during serving this URL:' n += '\n url: %s' % url n += '\n referrer: %s' % referrer ss = traceback.format_exc(exc) n += '\n' + indent(ss, '| ') self.exceptions.append(n) if 'library' in request.matchdict: library = self.get_current_library_name(request) url_refresh = '/libraries/%s/refresh_library' % library else: url_refresh = None u = unicode(s, 'utf-8') logger.error(u) return {'exception': u, 'url_refresh': url_refresh} def png_error_catch2(self, request, func): """ func is supposed to return an image response. If it raises an exception, we create an image with the error and then we add the exception to the list of exceptions. """ try: return func() except Exception as e: import traceback s = traceback.format_exc(e) try: logger.error(s) except UnicodeEncodeError: pass s = str(s) url = request.url referrer = request.referrer n = 'Error during rendering an image.' n+= '\n url: %s' % url n+= '\n referrer: %s' % referrer n += '\n' + indent(s, '| ') self.exceptions.append(n) from mcdp_web.utils.image_error_catch_imp import response_image return response_image(request, s) def view_docs(self, request): # XXX check this docname = str(request.matchdict['document']) # unicode # from pkg_resources import resource_filename # @UnresolvedImport res = self.render_markdown_doc(docname) res.update(self.get_jinja_hooks(request)) return res def render_markdown_doc(self, docname): package = dir_from_package_name('mcdp_data') docs = os.path.join(package, 'docs') f = os.path.join(docs, '%s.md' % docname) import codecs data = codecs.open(f, encoding='utf-8').read() # XXX data_str = data.encode('utf-8') html = render_markdown(data_str) html_u = unicode(html, 'utf-8') return {'contents': html_u} # This is where we keep all the URLS def get_lmv_url(self, library, model, view): url = '/libraries/%s/models/%s/views/%s/' % (library, model, view) return url def get_ltv_url(self, library, template, view): url = '/libraries/%s/templates/%s/views/%s/' % (library, template, view) return url def get_lpv_url(self, library, poset, view): url = '/libraries/%s/posets/%s/views/%s/' % (library, poset, view) return url def get_lib_template_view_url(self, library, template, view): url = '/libraries/%s/templates/%s/views/%s/' % (library, template, view) return url def get_model_name(self, request): model_name = str(request.matchdict['model_name']) # unicod return model_name def get_current_view(self, request): url = request.url for x in self._get_views(): if '/' + x + '/' in url: return x assert False, request.url def get_navigation_links(self, request): """ Pass this as "navigation" to the page. """ current_thing = None if 'model_name' in request.matchdict: current_thing = current_model = self.get_model_name(request) current_view = self.get_current_view(request) else: current_model = None current_view = None if 'template_name' in request.matchdict: current_thing = current_template = str(request.matchdict['template_name']) else: current_template = None if 'poset_name' in request.matchdict: current_thing = current_poset = str(request.matchdict['poset_name']) else: current_poset = None if 'value_name' in request.matchdict: current_thing = current_value = str(request.matchdict['value_name']) else: current_value = None current_library = self.get_current_library_name(request) library = self.get_library(request) d = {} models = self.list_of_models(request) d['current_thing'] = current_thing d['current_library'] = current_library d['current_template'] = current_template d['current_poset'] = current_poset d['current_model'] = current_model d['current_view'] = current_view documents = library._list_with_extension(MCDPLibrary.ext_doc_md) d['documents'] = [] for id_doc in documents: url = '/libraries/%s/%s.html' % (current_library, id_doc) desc = dict(id_document=id_doc, name=id_doc, url=url, current=False) d['documents'].append(desc) d['models'] = [] for m in natural_sorted(models): is_current = m == current_model url = self.get_lmv_url(library=current_library, model=m, view='syntax') name = "Model: %s" % m desc = dict(id_ndp=m, name=name, url=url, current=is_current) d['models'].append(desc) templates = library.list_templates() d['templates'] = [] for t in natural_sorted(templates): is_current = (t == current_template) url = self.get_lib_template_view_url(library=current_library, template=t, view='syntax') # XXX name = "Template: %s" % t desc = dict(name=name, url=url, current=is_current) d['templates'].append(desc) posets = library.list_posets() d['posets'] = [] for p in natural_sorted(posets): is_current = (p == current_poset) url = self.get_lpv_url(library=current_library, poset=p, view='syntax') name = "Poset: %s" % p desc = dict(name=name, url=url, current=is_current) d['posets'].append(desc) values = library.list_values() d['values'] = [] for v in natural_sorted(values): is_current = (v == current_value) url = '/libraries/%s/values/%s/views/edit_fancy/' % (current_library, v) name = "Value: %s" % v desc = dict(name=name, url=url, current=is_current) d['values'].append(desc) d['views'] = [] views = self._get_views() for v in views: view = self.views[v] is_current = v == current_view url = self.get_lmv_url(library=current_library, model=current_model, view=v) name = "View: %s" % view['desc'] desc = dict(name=name, url=url, current=is_current) d['views'].append(desc) libraries = self.list_libraries() # just the list of names d['libraries'] = [] libname2desc = {} for l in natural_sorted(libraries): is_current = l == current_library url = '/libraries/%s/' % l #name = "Library: %s" % l name = l desc = dict(name=name, url=url, current=is_current) libname2desc[l] =desc d['libraries'].append(desc) indexed = self.get_libraries_indexed_by_dir() indexed = [(sup, [libname2desc[_] for _ in l]) for sup, l in indexed] # for sup, libraries in libraries_indexed # for l in libraries # l['name'], l['url'] d['libraries_indexed'] = indexed return d def get_libraries_indexed_by_dir(self): """ returns a list of tuples (dirname, list(libname)) """ from collections import defaultdict path2libraries = defaultdict(lambda: []) for libname, data in self.libraries.items(): path = data['path'] sup = os.path.basename(os.path.dirname(path)) path2libraries[sup].append(libname) res = [] for sup in natural_sorted(path2libraries): r = (sup, natural_sorted(path2libraries[sup])) res.append(r) return res def get_jinja_hooks(self, request): """ Returns a set of useful template functions. """ d = {} d['version'] = lambda: mocdp.__version__ d['render_library_doc'] = lambda docname: self._render_library_doc(request, docname) d['has_library_doc'] = lambda docname: self._has_library_doc(request, docname) return d def _has_library_doc(self, request, document): l = self.get_library(request) filename = '%s.%s' % (document, MCDPLibrary.ext_doc_md) return l.file_exists(filename) @contract(returns=str) def _render_library_doc(self, request, document): import codecs l = self.get_library(request) strict = int(request.params.get('strict', '0')) filename = '%s.%s' % (document, MCDPLibrary.ext_doc_md) f = l._get_file_data(filename) realpath = f['realpath'] # read unicode data_unicode = codecs.open(realpath, encoding='utf-8').read() data_str = data_unicode.encode('utf-8') raise_errors = bool(strict) html = render_complete(library=l, s=data_str, realpath=realpath, raise_errors=raise_errors) return html def view_library_doc(self, request): """ '/libraries/{library}/{document}.html' """ # f['data'] not utf-8 # reopen as utf-8 document = str(request.matchdict['document']) html = self._render_library_doc(request, document) # we work with utf-8 strings assert isinstance(html, str) # but we need to convert to unicode later html = unicode(html, 'utf-8') res = {} res['contents'] = html res['title'] = document res['navigation'] = self.get_navigation_links(request) res['print'] = bool(request.params.get('print', False)) res.update(self.get_jinja_hooks(request)) return res def view_library_asset(self, request): l = self.get_library(request) asset = str(request.matchdict['asset']) ext = str(request.matchdict['ext']) filename = '%s.%s' % (asset, ext) f = l._get_file_data(filename) data = f['data'] content_type = get_mime_for_format(ext) from mcdp_web.utils.response import response_data return response_data(request, data, content_type) def exit(self, request): # @UnusedVariable setattr(self.server, '_BaseServer__shutdown_request', True) return {} def serve(self, port): config = Configurator() config.add_static_view(name='static', path='static') config.include('pyramid_jinja2') AppEditor.config(self, config) AppVisualization.config(self, config) AppQR.config(self, config) AppSolver.config(self, config) AppInteractive.config(self, config) AppEditorFancyGeneric.config(self, config) WebAppImages.config(self, config) AppSolver2.config(self, config) config.add_route('index', '/') config.add_view(self.view_index, route_name='index', renderer='index.jinja2') config.add_route('list_libraries', '/libraries/') config.add_view(self.view_list_libraries, route_name='list_libraries', renderer='list_libraries.jinja2') config.add_route('library_index', '/libraries/{library}/') config.add_view(self.view_list, route_name='library_index', renderer='library_index.jinja2') config.add_route('library_doc', '/libraries/{library}/{document}.html') config.add_view(self.view_library_doc, route_name='library_doc', renderer='library_doc.jinja2') config.add_route('library_asset', '/libraries/{library}/{asset}.{ext}') config.add_view(self.view_library_asset, route_name='library_asset') config.add_route('docs', '/docs/{document}/') config.add_view(self.view_docs, route_name='docs', renderer='language.jinja2') config.add_route('empty', '/empty') config.add_view(self.view_index, route_name='empty', renderer='empty.jinja2') config.add_route('refresh_library', '/libraries/{library}/refresh_library') config.add_view(self.view_refresh_library, route_name='refresh_library') config.add_view(self.view_exception, context=Exception, renderer='exception.jinja2') config.add_route('exit', '/exit') config.add_view(self.exit, route_name='exit', renderer='empty.jinja2') config.add_route('exceptions', '/exceptions') config.add_view(self.view_exceptions_occurred, route_name='exceptions', renderer='json') config.add_route('exceptions_formatted', '/exceptions_formatted') config.add_view(self.view_exceptions_occurred, route_name='exceptions_formatted', renderer='exceptions_formatted.jinja2') # mainly used for wget config.add_route('robots', '/robots.txt') def serve_robots(request): # @UnusedVariable body = "User-agent: *\nDisallow:" return Response(content_type='text/plain', body=body) config.add_view(serve_robots, route_name='robots') config.add_notfound_view(self.view_not_found, renderer='404.jinja2') app = config.make_wsgi_app() self.server = make_server('0.0.0.0', port, app) self.server.serve_forever()
def solve_main( logger, config_dirs, maindir, cache_dir, model_name, lower, upper, out_dir, max_steps, query_strings, intervals, _exp_advanced, expect_nres, imp, expect_nimp, plot, do_movie, # expect_res=None, expect_res, # @UnusedVariable make, ): if out_dir is None: out = solve_get_output_dir(prefix="out/out") else: out = out_dir logger.info("Using output dir %r" % out) librarian = Librarian() logger.info("Looking for libraries in %s..." % config_dirs) for e in config_dirs: librarian.find_libraries(e) logger.info("Found %d libraries." % len(librarian.get_libraries())) library = librarian.get_library_by_dir(maindir) if cache_dir is not None: library.use_cache_dir(cache_dir) ndp = library.load_ndp(model_name) basename = model_name if make or (plot and imp): ndp_labelled = get_labelled_version(ndp) else: ndp_labelled = ndp basename, dp = solve_get_dp_from_ndp(basename=basename, ndp=ndp_labelled, lower=lower, upper=upper) F = dp.get_fun_space() R = dp.get_res_space() UR = UpperSets(R) query = " ".join(query_strings) c = library.parse_constant(query) tu = get_types_universe() try: tu.check_leq(c.unit, F) except NotLeq as e: msg = "The value given cannot be converted to functionality space." raise_wrapped(UserError, e, msg, unit=c.unit, F=F, compact=True) fg = express_value_in_isomorphic_space(c.unit, c.value, F) logger.info("query: %s" % F.format(fg)) tracer = Tracer(logger=logger) res, trace = solve_meat_solve(tracer, ndp, dp, fg, intervals, max_steps, _exp_advanced) nres = len(res.minimals) if expect_nres is not None: if nres != expect_nres: msg = "Found wrong number of resources" raise_desc(ExpectationsNotMet, msg, expect_nres=expect_nres, nres=nres) if imp: M = dp.get_imp_space() nimplementations = 0 for r in res.minimals: ms = dp.get_implementations_f_r(fg, r) nimplementations += len(ms) s = "r = %s " % R.format(r) for j, m in enumerate(ms): # print('m = %s' % str(m)) s += "\n implementation %d of %d: m = %s " % (j + 1, len(ms), M.format(m)) if make: imp_dict = get_imp_as_recursive_dict(M, m) # , ignore_hidden=False) print("imp dict: %r" % imp_dict) context = {} artifact = ndp_make(ndp, imp_dict, context) print("artifact: %s" % artifact) tracer.log(s) if expect_nimp is not None: if expect_nimp != nimplementations: msg = "Found wrong number of implementations" raise_desc(ExpectationsNotMet, msg, expect_nimp=expect_nimp, nimplementations=nimplementations) # if expect_res is not None: # value = interpret_string(expect_res) # tracer.log('value: %s' % value) # res_expected = value.value # tu = get_types_universe() # # If it's a tuple of two elements, then we assume it's upper/lower bounds # if isinstance(value.unit, PosetProduct): # subs = value.unit.subs # assert len(subs) == 2, subs # # lower_UR_expected, upper_UR_expected = subs # lower_res_expected, upper_res_expected = value.value # # lower_bound = tu.get_embedding(lower_UR_expected, UR)[0](lower_res_expected) # upper_bound = tu.get_embedding(upper_UR_expected, UR)[0](upper_res_expected) # # tracer.log('lower: %s <= %s' % (UR.format(lower_bound), UR.format(res))) # tracer.log('upper: %s <= %s' % (UR.format(upper_bound), UR.format(res))) # # UR.check_leq(lower_bound, res) # UR.check_leq(res, upper_bound) # else: # # only one element: equality # UR_expected = value.unit # tu.check_leq(UR_expected, UR) # A_to_B, _B_to_A = tu.get_embedding(UR_expected, UR) # # res_expected_f = A_to_B(res_expected) # try: # UR.check_equal(res, res_expected_f) # except NotEqual as e: # raise_wrapped(ExpectationsNotMet, e, 'res is different', # res=res, res_expected=res_expected, compact=True) if plot: r = Report() if _exp_advanced: from mcdp_report.generic_report_utils import generic_report generic_report(r, dp, trace, annotation=None, axis0=(0, 0, 0, 0)) else: f = r.figure() from mcdp_report.generic_report_utils import generic_plot generic_plot(f, space=UR, value=res) from mcdp_report.generic_report_utils import generic_report_trace generic_report_trace(r, ndp, dp, trace, out, do_movie=do_movie) out_html = os.path.join(out, "report.html") logger.info("writing to %r" % out_html) r.to_html(out_html) if plot and imp: from mcdp_report_ndp_tests.test1 import GetValues from mcdp_report.gg_ndp import gvgen_from_ndp from mcdp_report.gdc import STYLE_GREENREDSYM from mcdp_report.gg_utils import gg_figure M = dp.get_imp_space() report_solutions = Report() for i, r in enumerate(res.minimals): ms = dp.get_implementations_f_r(fg, r) for j, m in enumerate(ms): imp_dict = get_imp_as_recursive_dict(M, m) images_paths = library.get_images_paths() gv = GetValues(ndp=ndp, imp_dict=imp_dict, nu=upper, nl=1) setattr(ndp, "_hack_force_enclose", True) with report_solutions.subsection("sol-%s-%s" % (i, j)) as rr: # Left right gg = gvgen_from_ndp( ndp=ndp, style=STYLE_GREENREDSYM, images_paths=images_paths, plotting_info=gv, direction="LR" ) gg_figure(rr, "figure", gg, do_png=True, do_pdf=True, do_svg=False, do_dot=False) # Top-bottom gg = gvgen_from_ndp( ndp=ndp, style=STYLE_GREENREDSYM, images_paths=images_paths, plotting_info=gv, direction="TB" ) gg_figure(rr, "figure2", gg, do_png=True, do_pdf=True, do_svg=False, do_dot=False) out_html = os.path.join(out, "report_solutions.html") logger.info("writing to %r" % out_html) report_solutions.to_html(out_html)
def other_reports(outdir, maindir, config_dirs, entry): print('config dirs: {}'.format(config_dirs)) librarian = Librarian() for e in config_dirs: librarian.find_libraries(e) default_library = librarian.get_library_by_dir(maindir) tex = '' library = default_library.load_library(entry.libname) if isinstance(entry, EntryTemplate): context = library._generate_context_with_hooks() template = library.load_spec(SPEC_TEMPLATES, entry.name, context) pdf = ndp_template_graph_enclosed(library=library, template=template, style=STYLE_GREENREDSYM, yourname=None, data_format='pdf', direction='TB', enclosed=True) base = entry.libname + '-' + entry.name + '-ndp_template_graph_enclosed.pdf' out = os.path.join(outdir, base) write_to_file(out, pdf) tex += '\n\\includegraphics{%s}' % base source_code = library._get_file_data(entry.name + '.mcdp_template')['data'] code_pdf = get_ast_as_pdf(s=source_code, parse_expr=Syntax.template) base = entry.libname + '-' + entry.name + '-syntax_pdf.pdf' out = os.path.join(outdir, base) write_to_file(out, code_pdf) tex += '\n\\includegraphics{%s}' % base if isinstance(entry, EntryNDP): filename = entry.name + '.mcdp' x = library._get_file_data(filename) data = {} data['model_name'] = entry.name data['s'] = x['data'].strip() data['filename'] = x['realpath'] data['params'] = {} data['library'] = library d = dict(allplots) plots = list(d.keys()) plots.remove('ndp_clean') plots.remove('ndp_default') plots.remove('ndp_greenred') plots.remove('dp_graph_tree_compact_labeled') # plots.remove('dp_graph_compact_labeled') for p in plots: # print('plotting %r ' % p) try: res = d[p](data) except DPSemanticError as e: logger.error(str(e)) continue except CmdException as e: logger.error(str(e)) continue 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 = entry.libname + '-' + entry.name + '-%s.%s' % (name, ext) out = os.path.join(outdir, base) write_to_file(out, x) if ext == 'pdf': tex += '\n\\includegraphics{%s}' % base print('outdir: %s' % outdir) print('entry: {}'.format(entry)) return tex
def solve_main( logger, config_dirs, maindir, cache_dir, model_name, lower, upper, out_dir, max_steps, query_strings, intervals, _exp_advanced, expect_nres, imp, expect_nimp, plot, do_movie, # expect_res=None, expect_res, # @UnusedVariable make): if out_dir is None: out = solve_get_output_dir(prefix='out/out') else: out = out_dir logger.info('Using output dir %r' % out) librarian = Librarian() logger.info('Looking for libraries in %s...' % config_dirs) for e in config_dirs: librarian.find_libraries(e) logger.info('Found %d libraries.' % len(librarian.get_libraries())) library = librarian.get_library_by_dir(maindir) if cache_dir is not None: library.use_cache_dir(cache_dir) ndp = library.load_ndp(model_name) basename = model_name if make or (plot and imp): ndp_labelled = get_labelled_version(ndp) else: ndp_labelled = ndp basename, dp = solve_get_dp_from_ndp(basename=basename, ndp=ndp_labelled, lower=lower, upper=upper) F = dp.get_fun_space() R = dp.get_res_space() UR = UpperSets(R) query = " ".join(query_strings) c = library.parse_constant(query) tu = get_types_universe() try: tu.check_leq(c.unit, F) except NotLeq as e: msg = 'The value given cannot be converted to functionality space.' raise_wrapped(UserError, e, msg, unit=c.unit, F=F, compact=True) fg = express_value_in_isomorphic_space(c.unit, c.value, F) logger.info('query: %s' % F.format(fg)) tracer = Tracer(logger=logger) res, trace = solve_meat_solve_ftor(tracer, ndp, dp, fg, intervals, max_steps, _exp_advanced) nres = len(res.minimals) if expect_nres is not None: if nres != expect_nres: msg = 'Found wrong number of resources' raise_desc(ExpectationsNotMet, msg, expect_nres=expect_nres, nres=nres) if imp: M = dp.get_imp_space() nimplementations = 0 for r in res.minimals: ms = dp.get_implementations_f_r(fg, r) nimplementations += len(ms) s = 'r = %s ' % R.format(r) for j, m in enumerate(ms): # print('m = %s' % str(m)) s += "\n implementation %d of %d: m = %s " % (j + 1, len(ms), M.format(m)) if make: imp_dict = get_imp_as_recursive_dict( M, m) # , ignore_hidden=False) print('imp dict: %r' % imp_dict) context = {} artifact = ndp_make(ndp, imp_dict, context) print('artifact: %s' % artifact) tracer.log(s) if expect_nimp is not None: if expect_nimp != nimplementations: msg = 'Found wrong number of implementations' raise_desc(ExpectationsNotMet, msg, expect_nimp=expect_nimp, nimplementations=nimplementations) # if expect_res is not None: # value = interpret_string(expect_res) # tracer.log('value: %s' % value) # res_expected = value.value # tu = get_types_universe() # # If it's a tuple of two elements, then we assume it's upper/lower bounds # if isinstance(value.unit, PosetProduct): # subs = value.unit.subs # assert len(subs) == 2, subs # # lower_UR_expected, upper_UR_expected = subs # lower_res_expected, upper_res_expected = value.value # # lower_bound = tu.get_embedding(lower_UR_expected, UR)[0](lower_res_expected) # upper_bound = tu.get_embedding(upper_UR_expected, UR)[0](upper_res_expected) # # tracer.log('lower: %s <= %s' % (UR.format(lower_bound), UR.format(res))) # tracer.log('upper: %s <= %s' % (UR.format(upper_bound), UR.format(res))) # # UR.check_leq(lower_bound, res) # UR.check_leq(res, upper_bound) # else: # # only one element: equality # UR_expected = value.unit # tu.check_leq(UR_expected, UR) # A_to_B, _B_to_A = tu.get_embedding(UR_expected, UR) # # res_expected_f = A_to_B(res_expected) # try: # UR.check_equal(res, res_expected_f) # except NotEqual as e: # raise_wrapped(ExpectationsNotMet, e, 'res is different', # res=res, res_expected=res_expected, compact=True) if plot: r = Report() if _exp_advanced: from mcdp_report.generic_report_utils import generic_report generic_report(r, dp, trace, annotation=None, axis0=(0, 0, 0, 0)) else: f = r.figure() from mcdp_report.generic_report_utils import generic_plot generic_plot(f, space=UR, value=res) from mcdp_report.generic_report_utils import generic_report_trace generic_report_trace(r, ndp, dp, trace, out, do_movie=do_movie) out_html = os.path.join(out, 'report.html') logger.info('writing to %r' % out_html) r.to_html(out_html) if plot and imp: from mcdp_report_ndp_tests.test1 import GetValues from mcdp_report.gg_ndp import gvgen_from_ndp from mcdp_report.gdc import STYLE_GREENREDSYM from mcdp_report.gg_utils import gg_figure M = dp.get_imp_space() report_solutions = Report() for i, r in enumerate(res.minimals): ms = dp.get_implementations_f_r(fg, r) for j, m in enumerate(ms): imp_dict = get_imp_as_recursive_dict(M, m) images_paths = library.get_images_paths() image_source = ImagesFromPaths(images_paths) gv = GetValues(ndp=ndp, imp_dict=imp_dict, nu=upper, nl=1) setattr(ndp, '_hack_force_enclose', True) with report_solutions.subsection('sol-%s-%s' % (i, j)) as rr: # Left right gg = gvgen_from_ndp(ndp=ndp, style=STYLE_GREENREDSYM, image_source=image_source, plotting_info=gv, direction='LR') gg_figure(rr, 'figure', gg, do_png=True, do_pdf=True, do_svg=False, do_dot=False) # Top-bottom gg = gvgen_from_ndp(ndp=ndp, style=STYLE_GREENREDSYM, image_source=image_source, plotting_info=gv, direction='TB') gg_figure(rr, 'figure2', gg, do_png=True, do_pdf=True, do_svg=False, do_dot=False) out_html = os.path.join(out, 'report_solutions.html') logger.info('writing to %r' % out_html) report_solutions.to_html(out_html)
def go(self): logger.setLevel(logging.DEBUG) options = self.get_options() symbols = self.options.symbols if symbols is not None: symbols = open(symbols).read() else: symbols = '' if not options.contracts: disable_all() stylesheet = options.stylesheet # make sure it exists get_css_filename('compiled/%s' % stylesheet) params = options.get_extra() if len(params) < 1: raise ValueError('Please specify name.') config_dirs = options.config_dirs.split(":") maindir = options.maindir out_dir = options.out if options.cache: cache_dir = os.path.join(out_dir, '_cached', 'solve') else: cache_dir = None librarian = Librarian() for e in config_dirs: librarian.find_libraries(e) library = librarian.get_library_by_dir(maindir) if cache_dir is not None: library.use_cache_dir(cache_dir) docs = params if not docs: msg = 'At least one argument required.' raise_desc(UserError, msg) for docname in docs: if '/' in docname: docname0 = os.path.split(docname)[-1] logger.info("Using %r rather than %r" % (docname0, docname)) docname = docname0 suffix = '.' + MCDPConstants.ext_doc_md if docname.endswith(suffix): docname = docname.replace(suffix, '') basename = docname + suffix f = library._get_file_data(basename) data = f['data'] realpath = f['realpath'] generate_pdf = options.pdf_figures if out_dir is None: use_out_dir = os.path.dirname(realpath) else: use_out_dir = os.path.join('out', 'mcdp_render') raise_errors = not options.forgiving use_mathjax = bool(options.mathjax) html_filename = render(library, docname, data, realpath, use_out_dir, generate_pdf, stylesheet=stylesheet, symbols=symbols, raise_errors=raise_errors, use_mathjax=use_mathjax) if options.pdf: run_prince(html_filename)
def recompute_available(self): # all the ones we can discover repos = self.app.hi.db_view.repos for repo_name, repo in repos.items(): for shelf_name, shelf in repo.shelves.items(): self.shelves_all[shelf_name] = shelf # shelf:repo/shelfname # library:repo/shelf/library self.shelves_available = OrderedDict() # the ones that are actually in use self.shelves_used = OrderedDict() userstruct = self.get_user_struct() ui = userstruct.info for sname, shelf in self.shelves_all.items(): if shelf.get_acl().allowed2(Privileges.DISCOVER, ui): self.shelves_available[sname] = shelf else: #print('hiding shelf %r from %r' % (sname, user)) print shelf.get_acl() #print('shelves all: %s' % list(self.shelves_all)) #print('shelves available: %s' % list(self.shelves_available)) for sname in ui.get_subscriptions(): if sname in self.shelves_available: shelf = self.shelves_available[sname] acl = shelf.get_acl() if acl.allowed2(Privileges.READ, ui): self.shelves_used[sname] = self.shelves_available[sname] else: msg = 'User %r does not have %r for %r' % ( ui.username, Privileges.READ, sname) msg += '\n%s' % acl logger.error(msg) else: msg = 'Could not find shelf %r to which user %r is subscribed to.' % ( sname, ui.username) msg += '\n Available: %s' % list(self.shelves_available) logger.error(msg) #print('shelves used: %s' % list(self.shelves_used)) self.librarian = Librarian() self.libname2shelfname = {} self.shelfname2reponame = {} repos = self.app.hi.db_view.repos for repo_name, repo in repos.items(): for shelf_name, shelf in repo.shelves.items(): if shelf_name in self.shelfname2reponame: o = self.shelfname2reponame[shelf_name] msg = ('Two repos with same shelf %r: %r and %r.' % (shelf_name, repo_name, o)) for r in [o, repo_name]: msg += '\n Shelves for %r: %s' % ( r, format_list(sorted(self.repos[r].shelves))) raise ValueError(msg) self.shelfname2reponame[shelf_name] = repo_name for sname, shelf in self.shelves_all.items(): for libname in shelf.libraries: self.libname2shelfname[libname] = sname for sname, shelf in self.shelves_used.items(): if False: # logger.error('need to reimplement this part') for libname, libpath in shelf.get_libraries_path().items(): self.librarian.add_lib_by_path(libpath) self.libraries = self.librarian.get_libraries() for _short, data in self.libraries.items(): l = data['library'] path = data['path'] cache_dir = os.path.join(path, '_cached/mcdpweb_cache') l.use_cache_dir(cache_dir)
def other_reports(outdir, maindir, config_dirs, entry): print('config dirs: {}'.format(config_dirs)) librarian = Librarian() for e in config_dirs: librarian.find_libraries(e) default_library = librarian.get_library_by_dir(maindir) tex = '' library = default_library.load_library(entry.libname) if isinstance(entry, EntryTemplate): context = library._generate_context_with_hooks() template = library.load_template(entry.name, context) pdf = ndp_template_graph_enclosed(library=library, template=template, style=STYLE_GREENREDSYM, yourname=None, data_format='pdf', direction='TB', enclosed=True) base = entry.libname + '-' + entry.name + '-ndp_template_graph_enclosed.pdf' out = os.path.join(outdir, base) write_to_file(out, pdf) tex += '\n\\includegraphics{%s}' % base source_code = library._get_file_data(entry.name +'.mcdp_template')['data'] code_pdf = get_ast_as_pdf(s=source_code, parse_expr=Syntax.template) base = entry.libname + '-' + entry.name + '-syntax_pdf.pdf' out = os.path.join(outdir, base) write_to_file(out, code_pdf) tex += '\n\\includegraphics{%s}' % base if isinstance(entry, EntryNDP): filename = entry.name + '.mcdp' x = library._get_file_data(filename) data = {} data['model_name'] = entry.name data['s'] = x['data'].strip() data['filename'] = x['realpath'] data['params'] = {} data['library'] = library d = dict(allplots) plots = list(d.keys()) plots.remove('ndp_clean') plots.remove('ndp_default') plots.remove('ndp_greenred') plots.remove('dp_graph_tree_compact_labeled') # plots.remove('dp_graph_compact_labeled') for p in plots: # print('plotting %r ' % p) try: res = d[p](data) except DPSemanticError as e: print e continue except CmdException as e: print e continue 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 = entry.libname + '-' + entry.name + '-%s.%s' % (name, ext) out = os.path.join(outdir, base) write_to_file(out, x) if ext == 'pdf': tex += '\n\\includegraphics{%s}' % base print('outdir: %s' % outdir) print('entry: {}'.format(entry)) return tex
class Session(object): def __init__(self, app, request): ''' dirnames: list of directories where to find shelves ''' self.app = app self.shelves_all = {} self.request = request self.librarian = Librarian() self.authenticated_userid = request.authenticated_userid # used during auth procedure self.candidate_user = None self.soft_match = None self.next_location = None self.recompute_available() def set_last_request(self, request): self.request = request if self.authenticated_userid != request.authenticated_userid: logger.debug('login/logout detected') self.authenticated_userid = request.authenticated_userid self.recompute_available() def _get_app(self): from mcdp_web.main import WebApp return WebApp.singleton # @contract(returns='isinstance(UserInfo)') def get_user_struct(self, username=None): ''' It is the user 'anonymous' if no login was given. self.request.authenticated_userid == None == get_user().info.username == 'anonymous' ''' app = self.app user_db = app.hi.db_view.user_db if username is None: username = self.request.authenticated_userid if username is not None and not username in user_db: logger.error('User appears to have not existent id "%s".' % username) username = None if username is not None: username = username.encode('utf8') if username in user_db: return user_db.users[username] else: schema = DB.user data = schema.generate_empty( info=dict(username=username, name=username)) view = DB.view_manager.create_view_instance(schema, data) view.set_root() return view else: # username is None: return user_db.users[MCDPConstants.USER_ANONYMOUS] def notify_created_library(self, shelf_name, library_name): # @UnusedVariable ''' Called when we just created the library. ''' self.get_shelf(shelf_name).update_libraries() self.recompute_available() @contract(returns='seq(str)') def get_subscribed_shelves(self): return list(self.shelves_used) def recompute_available(self): # all the ones we can discover repos = self.app.hi.db_view.repos for repo_name, repo in repos.items(): for shelf_name, shelf in repo.shelves.items(): self.shelves_all[shelf_name] = shelf # shelf:repo/shelfname # library:repo/shelf/library self.shelves_available = OrderedDict() # the ones that are actually in use self.shelves_used = OrderedDict() userstruct = self.get_user_struct() ui = userstruct.info for sname, shelf in self.shelves_all.items(): if shelf.get_acl().allowed2(Privileges.DISCOVER, ui): self.shelves_available[sname] = shelf else: #print('hiding shelf %r from %r' % (sname, user)) print shelf.get_acl() #print('shelves all: %s' % list(self.shelves_all)) #print('shelves available: %s' % list(self.shelves_available)) for sname in ui.get_subscriptions(): if sname in self.shelves_available: shelf = self.shelves_available[sname] acl = shelf.get_acl() if acl.allowed2(Privileges.READ, ui): self.shelves_used[sname] = self.shelves_available[sname] else: msg = 'User %r does not have %r for %r' % ( ui.username, Privileges.READ, sname) msg += '\n%s' % acl logger.error(msg) else: msg = 'Could not find shelf %r to which user %r is subscribed to.' % ( sname, ui.username) msg += '\n Available: %s' % list(self.shelves_available) logger.error(msg) #print('shelves used: %s' % list(self.shelves_used)) self.librarian = Librarian() self.libname2shelfname = {} self.shelfname2reponame = {} repos = self.app.hi.db_view.repos for repo_name, repo in repos.items(): for shelf_name, shelf in repo.shelves.items(): if shelf_name in self.shelfname2reponame: o = self.shelfname2reponame[shelf_name] msg = ('Two repos with same shelf %r: %r and %r.' % (shelf_name, repo_name, o)) for r in [o, repo_name]: msg += '\n Shelves for %r: %s' % ( r, format_list(sorted(self.repos[r].shelves))) raise ValueError(msg) self.shelfname2reponame[shelf_name] = repo_name for sname, shelf in self.shelves_all.items(): for libname in shelf.libraries: self.libname2shelfname[libname] = sname for sname, shelf in self.shelves_used.items(): if False: # logger.error('need to reimplement this part') for libname, libpath in shelf.get_libraries_path().items(): self.librarian.add_lib_by_path(libpath) self.libraries = self.librarian.get_libraries() for _short, data in self.libraries.items(): l = data['library'] path = data['path'] cache_dir = os.path.join(path, '_cached/mcdpweb_cache') l.use_cache_dir(cache_dir) def get_repo_shelf_for_libname(self, libname): sname = self.get_shelf_for_libname(libname) rname = self.shelfname2reponame[sname] return rname, sname def get_shelf_for_libname(self, libname): ''' Returns the name of the shelf for the given libname. ''' if not libname in self.libname2shelfname: msg = 'Could not find library %r.' % libname msg += '\n Available: %s' % sorted(self.libname2shelfname) raise NoSuchLibrary(msg) return self.libname2shelfname[libname] def get_shelf(self, shelfname): return self.shelves_all[shelfname] @contract(returns='list(str)') def list_libraries(self): """ Returns the list of libraries """ return sorted(self.libraries) # def get_library(self, library_name): # if not library_name in self.libraries: # msg = 'Could not find library %r.' % library_name # msg += '\n available: ' + format_list(sorted(self.libraries)) + '.' # raise_desc(ValueError, msg) # return self.libraries[library_name]['library'] def refresh_libraries(self): for l in [_['library'] for _ in self.libraries.values()]: l.delete_cache() from mcdp_report.gdc import get_images assert hasattr(get_images, 'cache') # in case it changes later get_images.cache = {} # def get_libraries_indexed_by_shelf(self): # """ # returns a list of tuples (dirname, list(libname)) # """ # res = [] # for sname, shelf in self.shelves_used.items(): # libnames = natural_sorted(shelf.libraries) # res.append((sname, libnames)) # return res def get_shelves_used(self): ''' Returns an ordered dict of shelves ''' return self.shelves_used def get_shelves_available(self): ''' Returns an ordered dict of shelves ''' return self.shelves_available