def clone_context(c): c2 = Context() c2.names = dict(**c.names) c2.connections = list(c.connections) c2.fnames = list(c.fnames) c2.rnames = list(c.rnames) return c2
def mark_errors(): s = """#comment mcdp { #@ syntax error }""" parse_expr = Syntax.ndpt_dp_rvalue x = parse_wrap(Syntax.ndpt_dp_rvalue, s)[0] context = Context() xr = parse_ndp_refine(x, context) suggestions = get_suggestions(xr) # make sure we can apply them _s2 = apply_suggestions(s, suggestions) def postprocess(block): x = parse_ndp_refine(block, context) return x html = ast_to_html(s, parse_expr=parse_expr, add_line_gutter=False, encapsulate_in_precode=False, postprocess=postprocess) text = project_html(html) s2 = """#comment mcdp { syntax error }""" assert_equal(text, s2) assert not '#@' in text
def solve_stats(ndp): res = {} query = { "endurance": "1.5 hour", "velocity": "1 m/s", "extra_power": " 1 W", "extra_payload": "100 g", "num_missions": "100 []", } context = Context() f = convert_string_query(ndp=ndp, query=query, context=context) dp0 = ndp.get_dp() dpL, dpU = get_dp_bounds(dp0, nl=1, nu=1) F = dp0.get_fun_space() F.belongs(f) from mcdp import logger traceL = Tracer(logger=logger) resL = dpL.solve_trace(f, traceL) traceU = Tracer(logger=logger) resU = dpU.solve_trace(f, traceU) R = dp0.get_res_space() UR = UpperSets(R) print('resultsL: %s' % UR.format(resL)) print('resultsU: %s' % UR.format(resU)) res['traceL'] = traceL res['traceU'] = traceU res['resL'] = resL res['resU'] = resU res['nsteps'] = 100 return res
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 check_mark_suggestions(): s = """#comment mcdp { provides a [Nat] }""" parse_expr = Syntax.ndpt_dp_rvalue x = parse_wrap(Syntax.ndpt_dp_rvalue, s)[0] context = Context() xr = parse_ndp_refine(x, context) suggestions = get_suggestions(xr) # make sure we can apply them _s2 = apply_suggestions(s, suggestions) def postprocess(block): x = parse_ndp_refine(block, context) return x html = ast_to_html(s, parse_expr=parse_expr, add_line_gutter=False, encapsulate_in_precode=False, postprocess=postprocess) for where, replacement in suggestions: # @UnusedVariable #print('suggestion: %r' % replacement) html = html_mark(html, where, "suggestion") assert 'suggestion' in html
def __copy__(self): c = Context() c.names = dict(**self.context.names) c.connections = list(self.context.connections) c.fnames = list(self.context.fnames) c.rnames = list(self.context.rnames) return CompositeNamedDP(c)
def get_gg(self, mf): from mcdp_report.gg_ndp import gvgen_from_ndp template = mf.get_template() library = mf.get_library() yourname = mf.get_yourname() if library is not None: context = library._generate_context_with_hooks() else: from mocdp.comp.context import Context context = Context() ndp = template.get_template_with_holes(context) if self.templatize_children: from mcdp_figures.figures_ndp import templatize_children_for_figures ndp = templatize_children_for_figures(ndp, enclosed=self.enclosed) if self.enclosed: setattr(ndp, '_hack_force_enclose', True) images_paths = library.get_images_paths() image_source = ImagesFromPaths(images_paths) gg = gvgen_from_ndp(ndp, style=self.style, direction=self.direction, image_source=image_source, yourname=yourname, skip_initial=True) return gg
def from_parts(name2ndp, connections, fnames, rnames): c = Context() c.names = name2ndp c.connections = connections c.fnames = fnames c.rnames = rnames return CompositeNamedDP(c)
def eval_rvalue_as_constant(s): """ Parses as an rvalue (resource) and evaluates as a constant value. Returns ValueWithUnit. """ parsed = parse_wrap(Syntax.rvalue, s)[0] context = Context() from mcdp_lang.eval_constant_imp import eval_constant value = eval_constant(parsed, context) return value
def _generate_context_with_hooks(self): context = Context() context.load_ndp_hooks = [self.load_ndp] context.load_posets_hooks = [self.load_poset] context.load_primitivedp_hooks = [self.load_primitivedp] context.load_template_hooks = [self.load_template] context.load_library_hooks = [self.load_library] return context
def check_tuples2(): s = "<1g, 5J>" parsed = parse_wrap(Syntax.rvalue, s)[0] context = Context() _ret = eval_rvalue(parsed, context) #print(ret) same("take(<1g, 5J>, 1)", "5 J")
def check_suggestions(filename, source): # @UnusedVariable # skip generated files (hack) if 'drone_unc2_' in filename: return # print filename source = open(filename).read() x = parse_wrap(Syntax.ndpt_dp_rvalue, source)[0] xr = parse_ndp_refine(x, Context()) suggestions = get_suggestions(xr) for w, r in suggestions: # @UnusedVariable #print('"%s" -> "%s"' % (w.string[w.character:w.character_end], r)) pass # print source.__repr__() print(source) s2 = apply_suggestions(source, suggestions) print(s2) # if suggestions: # print(s2) # do it a second time x = parse_wrap(Syntax.ndpt_dp_rvalue, s2)[0] xr = parse_ndp_refine(x, Context()) suggestions2 = get_suggestions(xr) s3 = apply_suggestions(s2, suggestions2) # the third time, there should not be any more suggestions x = parse_wrap(Syntax.ndpt_dp_rvalue, s3)[0] xr = parse_ndp_refine(x, Context()) suggestions3 = get_suggestions(xr) if suggestions3: msg = 'I expected that there are at most 2 rounds of suggestions.' raise_desc(ValueError, msg, s=source, s2=s2, s3=s3, suggestions=suggestions, suggestions2=suggestions2, suggestions3=suggestions3)
def actual_load(): # maybe we should clone l = self.clone() #logger.debug('Parsing %r' % (name)) context_mine = Context() res = parsing_function(l, data, realpath, context=context_mine) setattr(res, MCDPConstants.ATTR_LOAD_NAME, name) return dict(res=res, context_warnings=context_mine.warnings, generation=current_generation)
def parse_template(string, context=None): from mcdp_lang.syntax import Syntax from mocdp.comp.context import Context if context is None: context = Context() expr = Syntax.template x = parse_wrap(expr, string)[0] x = parse_template_refine(x, context) res = parse_template_eval(x, context) return res
def __init__(self, context): self.context = Context() self.context.names = context.names.copy() self.context.connections = list(context.connections) self.context.fnames = list(context.fnames) self.context.rnames = list(context.rnames) check_consistent_data(self.context.names, self.context.fnames, self.context.rnames, self.context.connections) self._rnames = list(self.context.rnames) self._fnames = list(self.context.fnames)
def parse_primitivedp(string, context=None): from mocdp.comp.context import Context from mcdp_lang.syntax import Syntax v = parse_wrap(Syntax.primitivedp_expr, string)[0] if context is None: context = Context() v2 = parse_primitivedp_refine(v, context) res = parse_primitivedp_eval(v2, context) return res
def parse_poset(string, context=None): from mocdp.comp.context import Context from .syntax import Syntax v = parse_wrap(Syntax.space, string)[0] if context is None: context = Context() v2 = parse_poset_refine(v, context) res = parse_poset_eval(v2, context) return res
def callback(tag0): context = Context() load = lambda x: library.load_poset(x, context=context) parse = lambda x: library.parse_poset(x, realpath=realpath, context=context) poset = load_or_parse_from_tag(tag0, load, parse) mf = MakeFiguresPoset(poset=poset, image_source=image_source) formats = ['svg'] if generate_pdf: formats.append('pdf') data = mf.get_figure(which, formats) tag = make_tag(tag0, which, data, ndp=None, template=None, poset=poset) return tag
def callback(tag0): context = Context() load = lambda x: library.load_spec(SPEC_TEMPLATES, x, context=context) parse = lambda x: library.parse_template(x, realpath=realpath, context=context) template = load_or_parse_from_tag(tag0, load, parse) mf = MakeFiguresTemplate(template=template, library=library, yourname=None) # XXX formats = ['svg'] if generate_pdf: formats.append('pdf') data = mf.get_figure(which,formats) tag = make_tag(tag0, which, data, ndp=None, template=template) return tag
def parse_constant(string, context=None): from mcdp_lang.syntax import Syntax from mocdp.comp.context import Context expr = Syntax.rvalue x = parse_wrap(expr, string)[0] if context is None: context = Context() x = parse_constant_refine(x, context) res = parse_constant_eval(x, context) return res
def cndp_create_one_without_some_connections(ndp, exclude_connections, names): """ Creates a new CompositeNDP without some of the connections. A new function / resource pair is created for each cut connection. """ from mocdp.comp.context import Context context = Context() # Create the fun/res node in the original order for fname in ndp.get_fnames(): # simply copy the functionnode - it might be a LabeledNDP name = get_name_for_fun_node(fname) fndp = ndp.get_name2ndp()[name] context.fnames.append(fname) context.add_ndp(name, fndp) for rname in ndp.get_rnames(): # simply copy the functionnode - it might be a LabeledNDP name = get_name_for_res_node(rname) rndp = ndp.get_name2ndp()[name] context.rnames.append(rname) context.add_ndp(name, rndp) for _name, _ndp in ndp.get_name2ndp().items(): isf, fname = is_fun_node_name(_name) isr, rname = is_res_node_name(_name) if isf and fname in ndp.get_fnames(): pass elif isr and rname in ndp.get_rnames(): pass else: # print('regular: %r' % _name) context.add_ndp(_name, _ndp) for c in ndp.get_connections(): if c in exclude_connections: continue # print('adding connection %s' % str(c)) context.connections.append(c) # print('done') # for each cut connection for e, name in zip(exclude_connections, names): S = context.get_rtype(CResource(e.dp1, e.s1)) fn = context.add_ndp_fun_node(name, S) rn = context.add_ndp_res_node(name, S) c1 = Connection(e.dp1, e.s1, rn, name) c2 = Connection(fn, name, e.dp2, e.s2) context.connections.append(c1) context.connections.append(c2) return CompositeNamedDP.from_context(context)
def callback(tag0): assert tag0.parent is not None context = Context() load = lambda x: library.load_ndp(x, context=context) parse = lambda x: library.parse_ndp(x, realpath=realpath, context=context) ndp = load_or_parse_from_tag(tag0, load, parse) mf = MakeFiguresNDP(ndp=ndp, image_source=image_source, yourname=None) # XXX formats = ['svg'] if generate_pdf: formats.append('pdf') data = mf.get_figure(which,formats) tag = make_tag(tag0, which, data, ndp=ndp, template=None) return tag
def interpret_params_1string(p, F, context=None): if context is None: context = Context() res = parse_wrap(Syntax.constant_value, p)[0] vu = eval_constant(res, context) Fd = vu.unit fd = vu.value tu = get_types_universe() tu.check_leq(Fd, F) A_to_B, _ = tu.get_embedding(Fd, F) fg = A_to_B(fd) return fg
def parse_ndp(string, context=None): from mocdp.comp.context import Context from .syntax import Syntax from mocdp.comp.interfaces import NamedDP if context is None: context = Context() expr = parse_wrap(Syntax.ndpt_dp_rvalue, string)[0] expr2 = parse_ndp_refine(expr, context) res = parse_ndp_eval(expr2, context) assert isinstance(res, NamedDP), res return res
def dpgraph_translate_rn(context, name, rn, rn2): def translate_connections(c): if c.dp1 == name and c.s1 == rn: c = Connection(name, rn2, c.dp2, c.s2) return c connections2 = map(translate_connections, context.connections) names2 = context.names.copy() names2[name] = wrap_change_name_resource(context.names[name], rn, rn2) c2 = Context() c2.rnames = context.rnames c2.fnames = context.fnames c2.connections = connections2 c2.names = names2 return dpgraph_making_sure_no_reps(c2)
def dpgraph_translate_fn(context, name, fn, fn2): def translate_connections(c): if c.dp2 == name and c.s2 == fn: c = Connection(c.dp1, c.s1, name, fn2) return c connections2 = map(translate_connections, context.connections) names2 = context.names.copy() names2[name] = wrap_change_name_function(context.names[name], fn, fn2) c2 = Context() c2.rnames = context.rnames c2.fnames = context.fnames c2.connections = connections2 c2.names = names2 return dpgraph_making_sure_no_reps(c2)
def parse_ndp(string, context=None): from mocdp.comp.context import Context from .syntax import Syntax from mocdp.comp.interfaces import NamedDP if context is None: context = Context() expr = parse_wrap(Syntax.ndpt_dp_rvalue, string)[0] # logger.debug('TMP:\n'+ recursive_print(expr)) expr2 = parse_ndp_refine(expr, context) # expr2 = expr # logger.debug('TMP:\n'+ recursive_print(expr2)) res = parse_ndp_eval(expr2, context) assert isinstance(res, NamedDP), res return res
def try_corrections2(s): x = parse_wrap(Syntax.ndpt_dp_rvalue, s)[0] context = Context() xr = parse_ndp_refine(x, context) print indent(recursive_print(xr), 'xr|') suggestions = get_suggestions(xr) for orig_where, sub in suggestions: orig_1 = orig_where.string[orig_where.character:orig_where. character_end] print 'Change %r in %r' % (orig_1, sub) s2 = apply_suggestions(s, suggestions) #print s2 _x2 = parse_wrap(Syntax.ndpt_dp_rvalue, s2)[0] return s2
def ignore_some(ndp, ignore_fnames, ignore_rnames): """ Ignores some functionalities or resources """ fnames0 = ndp.get_fnames() rnames0 = ndp.get_rnames() for fname in ignore_fnames: check_isinstance(fname, str) if not fname in fnames0: msg = 'Could not find functionality %r in %r.' % (fname, fnames0) raise_desc(ValueError, msg, fname=fname, fnames=fnames0) for rname in ignore_rnames: check_isinstance(rname, str) if not rname in rnames0: msg = 'Could not find resource %r in %r.' % (rname, rnames0) raise_desc(ValueError, msg, rname=rname, rnames=rnames0) c = Context() orig = '_orig' c.add_ndp(orig, ndp) for fname in ndp.get_fnames(): F = ndp.get_ftype(fname) if fname in ignore_fnames: dp = Constant(F, F.get_bottom()) n = '_const_f_%s' % fname c.add_ndp(n, dpwrap(dp, [], fname)) else: n = c.add_ndp_fun_node(fname, F) con = Connection(n, fname, orig, fname) c.add_connection(con) for rname in ndp.get_rnames(): R = ndp.get_rtype(rname) if rname in ignore_rnames: dp = LimitMaximals(R, R.get_maximal_elements()) n = '_const_r_%s' % rname c.add_ndp(n, dpwrap(dp, rname, [])) else: n = c.add_ndp_res_node(rname, R) con = Connection(orig, rname, n, rname) c.add_connection(con) return CompositeNamedDP.from_context(c)
def check_join_not_existence(): """ A test for finite posets where the join might not exist. """ from mcdp_library.library import MCDPLibrary l = MCDPLibrary() add_def_poset( l, 'P', """ finite_poset { a <= b <= c A <= B <= C } """) # parse_wrap(Syntax.LOAD, '`') # parse_wrap(Syntax.posetname, 'P') # print Syntax.load_poset # parse_wrap(Syntax.load_poset, '`P') # parse_wrap(Syntax.space_operand, '`P') # parse_wrap(Syntax.fun_statement, "provides x [`P]") ndp = l.parse_ndp(""" mcdp { provides x [`P] provides y [`P] requires z [`P] z >= x z >= y } """, context=Context()) dp = ndp.get_dp() res1 = dp.solve(('a', 'b')) P = l.load_poset('P') UR = UpperSets(P) UR.check_equal(res1, UpperSet(['b'], P)) res2 = dp.solve(('a', 'A')) UR.check_equal(res2, UpperSet([], P))