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_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_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_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():
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_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_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_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_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 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 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 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 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 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 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 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 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 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 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 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))
