def check_lang_namedtuple1(): parse_wrap(Syntax.PRODUCTWITHLABELS, 'product') parse_wrap(Syntax.space_product_with_labels, 'product(weight: g, energy: J)') P = parse_poset('product(weight: g, energy: J)') print(P) print(P.format((2.0, 1.0)))
def check_lang81(): # TODO: rename print parse_wrap(Syntax.rvalue_power_base, '(provided f)') print parse_wrap(Syntax.rvalue_power_expr_2, '(provided f) ^ 5') pass
def check_tuples6(): parsef = lambda s: parse_wrap(Syntax.fvalue, s)[0] parsef('take(out, 1)') parse_wrap(Syntax.lf_tuple_indexing, 'take(required out, 1)') parsef('take(required out, 1)')
def check_variables01(): some = [ 'variable x [m]', 'variable x [Nat]', 'variable x [dimensionless]', ] expr = Syntax.var_statement for s in some: parse_wrap(expr, s)
def check_catalogue2(): s = """ catalogue { provides plutonium [g] requires science [`scientific_objectives] a_ | 50 g | `scientific_objectives : find_ancient_life } """ parse_wrap(Syntax.ndpt_catalogue_dp, s)[0]
def check_lang4_composition(): parse_wrap(Syntax.rvalue, 'mission_time') s = """ dp { provides current [A] provides capacity [J] requires weight [g] implemented-by load times } """ parse_wrap(Syntax.ndpt_simple_dp_model, s)[0]
def check_lang(): idn = SyntaxIdentifiers.get_idn() parse_wrap(idn, 'battery') parse_wrap(idn, 'battery ') expr = idn + Literal('=') parse_wrap(expr, 'battery=') parse_wrap(Syntax.ndpt_load, 'load battery')
def check_lang6_composition(): parse_wrap(Syntax.rvalue, 'mission_time') parse_wrap(SyntaxCodeSpec.funcname, 'mocdp.example_battery.Mobility') parse_wrap(SyntaxCodeSpec.code_spec, 'code mocdp.example_battery.Mobility') parse_wrap(SyntaxCodeSpec.code_spec_with_args, 'code mocdp.example_battery.Mobility(a=1)')
def check_lang_namedtuple5(): parse_wrap(Syntax.fvalue_label_indexing, "capability..weight ")[0] parse_ndp(""" mcdp { requires capability [ product(weight: g, energy: J) ] capability..weight >= 1g capability..energy >= 1J } """)
def check_uncertainty7_uncertain(): string = "energy_density = between 1 and 2" parse_wrap(Syntax.setname_constant_uncertain, string) expr = parse_wrap(Syntax.line_expr, string)[0] logger.debug('TMP:\n' + recursive_print(expr)) s = """ mcdp { provides capacity [m] requires mass [m] energy_density = between 1 and 2 required mass * energy_density >= provided capacity } """ parse_ndp(s)
def check_lang_namedtuple3(): parse_wrap(Syntax.rvalue_label_indexing, "capability..weight ")[0] parse_ndp(""" mcdp { provides capability [ product(weight: g, energy: J) ] capability..weight <= 1g capability..energy <= 2J } """)
def mark_unparsable(s0, parse_expr): """ Returns a tuple: s, expr, commented where: s is the string with lines that do not parse marked as "#@" expr is the parsed expression (can be None) commented is the set of lines that had to be commented out Never raises DPSyntaxError """ commented = set() nlines = len(s0.split('\n')) s = s0 while True: if len(commented) == nlines: return s, None, commented try: expr = parse_wrap(parse_expr, s)[0] return s, expr, commented except DPSyntaxError as e: line = e.where.line assert line is not None if line == nlines: # all commented return s, None, commented if line in commented: return s, None, commented commented.add(line) s = comment_out(s, line - 1)
def test_escaping1(): p = parse_wrap(Syntax.constant_value, '<0g>')[0] s = list(print_html_inner(p))[0].transformed se = """<span class='MakeTuple' where_character='0' where_character_end='4'><span class='OpenBraceKeyword' where_character='0' where_character_end='1'><</span><span class='SimpleValue' where_character='1' where_character_end='3'><span class='ValueExpr' where_character='1' where_character_end='2'>0</span><span class='RcompUnit' where_character='2' where_character_end='3'>g</span></span><span class='CloseBraceKeyword' where_character='3' where_character_end='4'>></span></span>""" assert se == s
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 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 parse_wrap_semantic_error(string, expr, contains=None): """ Assert semantic error. If contains is not None, it is a substring that must be contained in the error. Returns the exception. """ if isinstance(expr, ParsingElement): expr = expr.get() try: res = parse_wrap(expr, string)[0] # note the 0, first element except DPSemanticError as e: if contains is not None: s = str(e) if not contains in s: msg = 'Expected a DPSemanticError with substring %r.' % contains raise_wrapped(TestFailed, e, msg, expr=find_parsing_element(expr), string=string) return e else: return e except BaseException as e: msg = 'Expected DPSemanticError, but obtained %s.' % type(e) raise_wrapped(TestFailed, e, msg, expr=find_parsing_element(expr), string=string) msg = 'Expected DPSemanticError, but no except was thrown.' raise_desc(TestFailed, msg, expr=find_parsing_element(expr), string=string, result=res) assert False
def spaces1(): string = """requires ciao [ m] \n"comment" """ expr = Syntax.line_expr x = parse_wrap(expr, string)[0] #print x # x2 = fix_whitespace(x) #print x2 assert_no_whitespace(x.comment) assert_no_whitespace(x.rnames.e0) string = ' 0 >= 2 ' expr = Syntax.constraint_expr_geq x = parse_wrap(expr, string)[0] # x2 = fix_whitespace(x) assert_no_whitespace(x.prep)
def parse_source(self, spec_name, source, context): parse_expr = specs[spec_name].parse_expr parse_refine = specs[spec_name].parse_refine # Here we parse and refine expr = parse_wrap(parse_expr, source)[0] expr2 = parse_refine(expr, context) return expr2
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 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_print(): s = """ mcdp { # provides f [m] f <= 10 m } """ x = parse_wrap(Syntax.ndpt_dp_rvalue, s)[0] s2 = ast_to_mcdpl(x) assert_equal(s.strip(), s2.strip())
def units_pixels(): # so 'pi' is forbidden as a keyword assert_raises(DPSyntaxError, parse_wrap, Keyword('pi'), 'pixels') parse_wrap(SyntaxIdentifiers.not_keyword + L('pixels'), 'pixels') parse_wrap(Syntax.pint_unit_simple, 'pixels') parse_wrap(Syntax.space_pint_unit, 'pixels') parse_wrap(Syntax.space_pint_unit, 'pixels/deg') parse_poset('pixels/deg') parse_poset('pixel/deg') parse_constant(' 1.0 pixels/deg')
def check_minmax3(): # TODO: rename # parse_wrap(Syntax.opname_f, 'min') # parse_wrap(Syntax.fvalue_binary, 'min(required r1, required r2)') parse_wrap(Syntax.fvalue, 'min(required r1, required r2)') ndp = parse_ndp(""" mcdp { provides f [Nat] requires r1 [Nat] requires r2 [Nat] provided f <= min(required r1, required r2) } """) dp = ndp.get_dp() check_isinstance(dp, MeetNDualDP)
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 sum03(): # sum_over_resources = sp(SUM + rname + REQUIRED_BY + ASTERISK, # lambda t: CDP.SumResources(t[0],t[1],t[2],t[3])) # sum_over_functions = sp(SUM + fname + PROVIDED_BY + ASTERISK, # lambda t: CDP.SumResources(t[0],t[1],t[2],t[3])) sor = Syntax.rvalue_sum_over_resources sof = Syntax.fvalue_sum_over_functions parse_wrap(sor, "sum r required by *") parse_wrap(sor, "∑ r required by *") parse_wrap(sof, "sum f provided by *") parse_wrap(sof, "∑ f provided by *")
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 check_lang_namedtuple6(): s = """namedproduct( tag: s )""" print('1') parse_wrap(Syntax.space_product_with_labels, s) print('2') parse_wrap(Syntax.space_operand, s) print('2b') parse_poset(s) s = """namedproduct( tag: S(DuckiebotIntersectionSignal) )""" print('3') parse_poset(s) print('4')
def parsing_error_recov10(): # # s="""mcdp { # # a = mcdp {} # # x = instance a # } # #dkokokeo""" # parse_ndp(s) # s="""a=instance mcdp { # a # }""" # parse_wrap(Syntax.setname_ndp_instance2, s) s="""a=instance mcdp { a }""" parse_wrap(Syntax.line_expr, s)
def check_tuples2(): #s = "take(<1g, 5J>, 1)" 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 new_uncertainty12(): s = """ catalogue { provides length [m] requires weight [g] 1 m <--| imp |--> 10 kg } """ parse_ndp(s) parse_wrap(Syntax.catalogue_entry_constant_uncertain, '10 kg +- 50 g') s = """ catalogue { provides length [m] requires weight [g] 1 m <--| imp |--> 10 kg +- 50 g } """ parse_ndp(s)
def test_escaping1(): p = parse_wrap(Syntax.constant_value, '<0g>')[0] s = list(print_html_inner(p))[0].transformed se = """<span class='MakeTuple' where_character='0' where_character_end='4'><span class='OpenBraceKeyword' where_character='0' where_character_end='1'><</span><span class='SimpleValue' where_character='1' where_character_end='3'><span class='ValueExpr' where_character='1' where_character_end='2'>0</span><span class='RcompUnit' where_character='2' where_character_end='3'>g</span></span><span class='CloseBraceKeyword' where_character='3' where_character_end='4'>></span></span>""" se = se.replace('where_character_end', ATTR_WHERE_CHAR_END) # first this se = se.replace('where_character', ATTR_WHERE_CHAR) assert_equal(se, s)
def check_lang9_max(): parse_wrap_check("""provides x [dimensionless]""", Syntax.fun_statement) parse_wrap_check("""requires x [dimensionless]""", Syntax.res_statement) parse_wrap_check( """ provides x [dimensionless] requires r [dimensionless] """, Syntax.simple_dp_model_stats) parse_wrap_check( """dp { provides x [dimensionless] requires r [dimensionless] implemented-by load SimpleNonlinearity1 }""", Syntax.ndpt_simple_dp_model) # parse_wrap(Syntax.rvalue_binary, 'max(f, g)') parse_wrap(Syntax.rvalue, 'max(f, g)') parse_wrap(Syntax.constraint_expr_geq, 'hnlin.x >= max(f, g)')
def spaces2(): expr = Syntax.python_style_multiline1 string = '"""ciao\n\tciao\nciao"""' x = parse_wrap(expr, string)[0] #print x.__repr__() assert_equal(x, 'ciao\n\tciao\nciao') # singles cannot have \n inside expr = Syntax.quoted string2 = '"ciao\n\tciao\nciao"' try: parse_wrap(expr, string2)[0] except DPSyntaxError: pass # The comment cannot be multiline expr = Syntax.line_expr string = """requires ciao [ m] \n'''this\nis\n\tmultiline''' """ try: parse_wrap(expr, string)[0] except DPSyntaxError: pass
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 check_lang9_max(): parse_wrap_check("""provides x [dimensionless]""", Syntax.fun_statement) parse_wrap_check("""requires x [dimensionless]""", Syntax.res_statement) parse_wrap_check(""" provides x [dimensionless] requires r [dimensionless] """, Syntax.simple_dp_model_stats) parse_wrap_check("""dp { provides x [dimensionless] requires r [dimensionless] implemented-by load SimpleNonlinearity1 }""", Syntax.ndpt_simple_dp_model) # parse_wrap(Syntax.rvalue_binary, 'max(f, g)') parse_wrap(Syntax.rvalue, 'max(f, g)') parse_wrap(Syntax.constraint_expr_geq, 'hnlin.x >= max(f, g)')
def assert_syntax_error(s, expr, desc=None): if isinstance(expr, ParsingElement): expr = expr.get() try: res = parse_wrap(expr, s) except DPSyntaxError: pass except BaseException as e: msg = "Expected syntax error, got %s." % type(e) raise_wrapped(Exception, e, msg, s=s) else: msg = "Expected an exception, instead succesfull instantiation." if desc: msg += '\n' + desc raise_desc(Exception, msg, s=s, res=res.repr_long())
def parse_wrap_check(string, expr, result=None): check_isinstance(string, str) if isinstance(expr, ParsingElement): expr = expr.get() try: res = parse_wrap(expr, string)[0] # note the 0, first element res0 = remove_where_info(res) if result is not None: assert_equal(result, res0) return res except BaseException as e: msg = 'Cannot parse %r' % string raise_wrapped(TestFailed, e, msg, expr=find_parsing_element(expr), string=string, expected=result)
def parse_wrap_syntax_error(string, expr): """ Assert syntax error """ if isinstance(expr, ParsingElement): expr = expr.get() try: res = parse_wrap(expr, string) _res = res[0] # note the 0, first element msg = 'Expected DPSyntaxError.' raise_desc(TestFailed, msg, res=res.__repr__()) except DPSyntaxError as e: return e except BaseException as e: msg = 'Expected DPSyntaxError.' raise_wrapped(TestFailed, e, msg, expr=find_parsing_element(expr), string=string)
def get_dependencies(self, s): assert isinstance(s, Entry), s if isinstance(s, EntryNDP): parse_expr = Syntax.ndpt_dp_rvalue ext = MCDPLibrary.ext_ndps elif isinstance(s, EntryTemplate): parse_expr = Syntax.template ext = MCDPLibrary.ext_templates elif isinstance(s, EntryPoset): parse_expr = Syntax.space ext = MCDPLibrary.ext_posets else: raise NotImplementedError(s.__repr__()) library = self.get_library(s.libname) basename = s.name + '.' + ext d = library._get_file_data(basename) string = d['data'] x = parse_wrap(parse_expr, string)[0] return self.collect_dependencies(s, x)
def check_lang80(): # TODO: rename s = """ mcdp { provides f [dimensionless] requires r [dimensionless] x = provided f required r >= x - 1 dimensionless } """ ndp = parse_ndp(s) dp = ndp.get_dp() print dp.repr_long() s = 'provided f' print parse_wrap(Syntax.rvalue, s) s = 'x - Nat:1' print parse_wrap(Syntax.rvalue, s) s = 'provided f - Nat:1' print parse_wrap(Syntax.rvalue, s)
def go(): try: # XXX: inefficient; we parse twice parse_tree = parse_wrap(parse_expr, string)[0] except DPSemanticError as e: msg = 'I only expected a DPSyntaxError' raise_wrapped(DPInternalError, e, msg, exc=sys.exc_info()) except DPSyntaxError as e: # This is the case in which we could not even parse from mcdp_report.html import mark_unparsable string2, expr, _commented_lines = mark_unparsable(string, parse_expr) res = format_exception_for_ajax_response(e, quiet=(DPSyntaxError,)) if expr is not None: try: html = ast_to_html(string2, ignore_line=None, add_line_gutter=False, encapsulate_in_precode=False, parse_expr=parse_expr, postprocess=None) res['highlight'] = html except DPSyntaxError: assert False, string2 else: res['highlight'] = html_mark_syntax_error(string, e) res['request'] = req return res try: class Tmp: parse_tree_interpreted = None def postprocess(block): Tmp.parse_tree_interpreted = parse_refine(block, context) return Tmp.parse_tree_interpreted try: try: highlight = ast_to_html(string, parse_expr=parse_expr, add_line_gutter=False, encapsulate_in_precode=False, postprocess=postprocess) except DPSemanticError: # Do it again without postprocess highlight = ast_to_html(string, parse_expr=parse_expr, add_line_gutter=False, encapsulate_in_precode=False, postprocess=None) raise thing = parse_eval(Tmp.parse_tree_interpreted, context) except (DPSemanticError, DPInternalError) as e: highlight_marked = html_mark(highlight, e.where, "semantic_error") self.last_processed2[key] = None # XXX res = format_exception_for_ajax_response(e, quiet=(DPSemanticError, DPInternalError)) res['highlight'] = highlight_marked res['request'] = req return res self.last_processed2[key] = thing except: self.last_processed2[key] = None # XXX raise warnings = [] for w in context.warnings: # w.msg warning = w.format_user() if w.where is not None: highlight = html_mark(highlight, w.where, "language_warning") # wheres = format_where(w.where, context_before=0, mark=None, arrow=False, # use_unicode=True, no_mark_arrow_if_longer_than=3) # warning += '\n\n' + indent(wheres, ' ') warnings.append(warning.strip()) sep = '-' * 80 language_warnings = ("\n\n" + sep + "\n\n").join(warnings) language_warnings_html = "\n".join(['<div class="language_warning">%s</div>' % w for w in warnings]) return {'ok': True, 'highlight': highlight, 'language_warnings': language_warnings, 'language_warnings_html': language_warnings_html, 'request': req}
def check_lang_namedtuple1(): parse_wrap(Syntax.PRODUCTWITHLABELS, 'product') parse_wrap(Syntax.space_product_with_labels, 'product(weight: g, energy: J)') P = parse_poset('product(weight: g, energy: J)') print P print P.format((2.0, 1.0))
def ast_to_html(s, parse_expr=None, ignore_line=None, add_line_gutter=True, encapsulate_in_precode=True, postprocess=None, # deprecated complete_document=None, extra_css=None, add_css=None, add_line_spans=None,): """ postprocess = function applied to parse tree """ if add_line_spans is not None and add_line_spans != False: warnings.warn('deprecated param add_line_spans') if parse_expr is None: raise Exception('Please add specific parse_expr (default=Syntax.ndpt_dp_rvalue)') if add_css is not None: warnings.warn('please do not use add_css', stacklevel=2) if complete_document is not None: warnings.warn('please do not use complete_document', stacklevel=2) if ignore_line is None: ignore_line = lambda _lineno: False if extra_css is not None: warnings.warn('please do not use extra_css', stacklevel=2) extra_css = '' s_lines, s_comments = isolate_comments(s) assert len(s_lines) == len(s_comments) num_empty_lines_start = 0 for line in s_lines: if line.strip() == '': num_empty_lines_start += 1 else: break num_empty_lines_end = 0 for line in reversed(s_lines): if line.strip() == '': num_empty_lines_end += 1 else: break # use = s_lines use = s.split('\n') full_lines = use[num_empty_lines_start: len(s_lines)- num_empty_lines_end] for_pyparsing = "\n".join(full_lines) block = parse_wrap(parse_expr, for_pyparsing)[0] if not isnamedtuplewhere(block): # pragma: no cover raise DPInternalError('unexpected', block=block) if postprocess is not None: block = postprocess(block) if not isnamedtuplewhere(block): raise ValueError(block) snippets = list(print_html_inner(block)) # the len is > 1 for mcdp_statements assert len(snippets) == 1, snippets snippet = snippets[0] transformed_p = snippet.transformed if block.where.character != 0: transformed_p = for_pyparsing[:block.where.character] + transformed_p def sanitize_comment(x): x = x.replace('>', '>') x = x.replace('<', '<') return x transformed = '\n' * num_empty_lines_start + transformed_p transformed = transformed + '\n' * num_empty_lines_end # out = transformed lines = transformed.split('\n') if len(lines) != len(s_comments): msg = 'Lost some lines while pretty printing: %s, %s' % (len(lines), len(s_comments)) raise DPInternalError(msg) out = "" for i, (line, comment) in enumerate(zip(lines, s_comments)): lineno = i + 1 if ignore_line(lineno): continue else: if '#' in line: w = line.index('#') before = line[:w] comment = line[w:] if comment.startswith(unparsable_marker): unparsable = comment[len(unparsable_marker):] linec = before + '<span class="unparsable">%s</span>' % sanitize_comment(unparsable) else: linec = before + '<span class="comment">%s</span>' % sanitize_comment(comment) else: linec = line if add_line_gutter: out += "<span class='line-gutter'>%2d</span>" % lineno out += "<span class='line-content'>" + linec + "</span>" else: out += linec if i != len(lines) - 1: out += '\n' if MCDPConstants.test_insist_correct_html_from_ast_to_html: from xml.etree import ElementTree as ET ET.fromstring(out) frag = "" if encapsulate_in_precode: frag += '<pre><code>' frag += out frag += '</code></pre>' else: frag += out return frag
def check_from_library1(): parse_wrap(Syntax.dpinstance_expr, 'instance load Sa')[0] parse_wrap(Syntax.dpinstance_expr, 'instance load(Sa)')[0] parse_wrap(Syntax.dpinstance_expr, 'instance load "Sa"')[0] parse_wrap(Syntax.dpinstance_expr, 'instance load("Sa")')[0] parse_wrap(Syntax.dpinstance_expr, "instance load 'Sa'")[0] parse_wrap(Syntax.dpinstance_expr, "instance load('Sa')")[0] parse_wrap(Syntax.dpinstance_expr, "new Sa")[0] parse_wrap(Syntax.dpinstance_expr, "new ('Sa')")[0] parse_wrap(Syntax.dpinstance_expr, "new('Sa')")[0] parse_wrap(Syntax.dpinstance_expr, "new 'Sa' ")[0] parse_wrap(Syntax.dpinstance_expr, "new Sa ")[0] parse_wrap(Syntax.code_spec, "code functions.call() ") parse_wrap(Syntax.space, "code functions.call() ") parse_wrap(Syntax.ndpt_dp_operand, "code functions.call() ") parse_wrap(Syntax.ndpt_dp_rvalue, "code functions.call() ")
def check_catalogue1(): s = """ a_ | 50 g | `scientific_objectives : find_ancient_life """ parse_wrap(Syntax.catalogue_row, s)[0]
def interpret_string_as_space(p): context = Context() res = parse_wrap(Syntax.space, p)[0] unit = eval_space(res, context) assert isinstance(unit, Space) return unit
def check_loop_result3(): parse_wrap(Syntax.primitivedp_expr, 'code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3)')[0] parse_wrap(Syntax.ndpt_simple_dp_model, """ dp { requires x [Nat] provides c [Nat] implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3) } """)[0] assert_semantic_error(""" mcdp { s = instance dp { requires x [Nat] provides c [Nat] # semantic error: does not exist implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3) } }""" ) assert_semantic_error(""" mcdp { s = instance dp { requires x [Nat] provides c [Nat] # semantic error: not a DP implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap(n=3) } }""" ) ndp = parse_ndp(""" mcdp { adp1 = dp { requires x [Nat] provides c [Nat] implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=3) } s = instance adp1 s.c >= s.x }""" ) # UNat = UpperSets(Nat()) dp = ndp.get_dp() print dp res = dp.solve(()) print res.__repr__() One = PosetProduct(()) U1 = UpperSets(One) U1.check_equal(res, One.U(())) ndp = parse_ndp(""" mcdp { adp1 = dp { requires x [Nat] provides c [Nat] implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=3) } adp2 = dp { requires x [Nat] provides c [Nat] implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=2) } s = instance choose(a: adp1, b: adp2) s.c >= s.x requires x for s }""" ) N = Nat() UNat = UpperSets(N) dp = ndp.get_dp() print dp res = dp.solve(()) print res UNat.check_equal(res, N.U(2))