umaudemc 0.12.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

umaudemc/formatter.py

@@ -89,23 +89,18 @@ def parse_state_format(sformat, strategy):
 	                                                tused > 0, sused > 0))
 
 
-def apply_edge_format(graph, origin, dest, eformat):
+def apply_edge_format(stmt, eformat):
 	"""
 	Edge label generator using a prebuilt format string.
 
-	:param graph: Rewriting graph the transition belong to.
-	:type graph: Maude rewriting graph.
-	:param origin: Index of the origin state within the graph.
-	:type origin: int
-	:param dest: Index of the destination state within the graph.
-	:type dest: int
+	:param stmt: Rule that caused the transition
+	:type stmt: Rule
 	:param eformat: Prebuilt format string.
 	:type eformat: str
 	:returns: Formatted edge label.
 	:rtype str
 	"""
 
-	stmt = graph.getRule(origin, dest)
 	label = stmt.getLabel()
 	line = stmt.getLineNumber()
 	opaque = ''
@@ -116,9 +111,8 @@ def apply_edge_format(graph, origin, dest, eformat):
 	return eformat.format(stmt=stmt, label=label, line=line, opaque=opaque)
 
 
-def apply_edge_format_strat(graph, origin, dest, eformat):
+def apply_edge_format_strat(trans, eformat):
 	"""Edge label generator for strategy-controlled using a prebuilt format string"""
-	trans = graph.getTransition(origin, dest)
 	opaque, label, stmt, line = '', '', '', ''
 
 	if trans.getType() == maude.StrategyRewriteGraph.SOLUTION:
@@ -150,9 +144,9 @@ def parse_edge_format(eformat, strategy):
 	eformat = re.sub(r'%(.\d+)?n', r'{line:\1}', eformat)
 
 	if strategy:
-		return lambda graph, origin, dest: apply_edge_format_strat(graph, origin, dest, eformat)
+		return lambda trans: apply_edge_format_strat(trans, eformat)
 	else:
-		return lambda graph, origin, dest: apply_edge_format(graph, origin, dest, eformat)
+		return lambda stmt: apply_edge_format(stmt, eformat)
 
 
 #
@@ -165,29 +159,30 @@ def print_term(graph, index):
 	return graph.getStateTerm(index)
 
 
-def print_transition(graph, origin, dest):
+def print_transition(stmt):
 	"""Default edge-label printing function"""
-	return graph.getRule(origin, dest)
+	return stmt
 
 
-def print_transition_strat(graph, origin, dest):
+def print_transition_strat(trans):
 	"""Default edge-label printing function with strategies"""
-	trans = graph.getTransition(origin, dest)
-	return {
-		maude.StrategyRewriteGraph.RULE_APPLICATION	: trans.getRule(),
-		maude.StrategyRewriteGraph.OPAQUE_STRATEGY	: trans.getStrategy(),
-		maude.StrategyRewriteGraph.SOLUTION		: ''
-	}[trans.getType()]
+	ttype = trans.getType()
+
+	if ttype == maude.StrategyRewriteGraph.RULE_APPLICATION:
+		return trans.getRule()
+	elif ttype == maude.StrategyRewriteGraph.OPAQUE_STRATEGY:
+		return trans.getStrategy()
+	else:
+		return ''
 
 
-def print_transition_label(graph, origin, dest):
+def print_transition_label(stmt):
 	"""Alternative edge-label printing function (only rule label)"""
-	return graph.getRule(origin, dest).getLabel()
+	return stmt.getLabel()
 
 
-def print_transition_strat_label(graph, origin, dest):
+def print_transition_strat_label(trans):
 	"""Alternative edge-label printing function with strategies (only rule/strategy label)"""
-	trans = graph.getTransition(origin, dest)
 	ttype = trans.getType()
 
 	if ttype == maude.StrategyRewriteGraph.RULE_APPLICATION:

umaudemc/formulae.py

@@ -22,7 +22,7 @@ def collect_aprops(form, aprops):
 
 
 def _add_path_premise_ctl(form, premise):
-	"""Add a premise to every path quantification in CTL* formulae""" 
+	"""Add a premise to every path quantification in CTL* formulae"""
 	head, *rest = form
 
 	if head == 'A_' or head == 'E_':
@@ -102,7 +102,7 @@ def _actionSpecParse(acspec, labels):
 
 
 def _formula2List(form, *extra_args):
-	"""Convert the formula parsed by Maude into an pure Python list"""
+	"""Convert the formula parsed by Maude into a pure Python list"""
 	prop_sort, variable_sort, labels = extra_args
 
 	if form.getSort() <= prop_sort:
@@ -170,7 +170,7 @@ def _boundSpecParse(bound):
 
 
 def _probFormula2List(form, prop_sort, aprops):
-	"""Convert the probabilistic formula parsed by Maude into an pure Python list"""
+	"""Convert the probabilistic formula parsed by Maude into a pure Python list"""
 
 	if form.getSort() <= prop_sort:
 		aprops.add(str(form))
@@ -269,7 +269,7 @@ class BaseParser:
 			self.templog.parseTerm('tokenize("{}")'.format(formula.replace('"', '\"'))),
 			self.templog.parseTerm(label_list)
 		)
-		parser_metamod.reduce()
+
 		extmod = maude.downModule(parser_metamod)
 
 		formula_kind = extmod.findSort('Formula').kind()

umaudemc/grapher.py

@@ -43,8 +43,8 @@ class DOTGrapher:
 		if bound == 0:
 			return
 
-		for next_state in graph.getNextStates(stateNr):
-			elabel = self.elabel(graph, stateNr, next_state) if self.elabel else None
+		for next_state, edge in graph.getTransitions(stateNr):
+			elabel = self.elabel(edge) if self.elabel else None
 			self.write_transition(stateNr, next_state, elabel)
 
 			if next_state not in self.visited:
@@ -67,7 +67,8 @@ class PDOTGrapher(DOTGrapher):
 		num, den = Fraction(p).limit_denominator().as_integer_ratio()
 
 		# Standard labels are used too
-		elabel = self.elabel(graph, start, end)
+		stmt = graph.getTransition(start, end) if graph.strategyControlled else graph.getRule(start, end)
+		elabel = self.elabel(stmt)
 
 		return f'{num}/{den} {elabel}' if p != 1.0 else elabel
 
@@ -123,14 +124,14 @@ class TikZGrapher:
 		if bound == 0:
 			return
 
-		for next_state in graph.getNextStates(stateNr):
+		for next_state, edge in graph.getTransitions(stateNr):
 			print(f'\t{self.printState(graph, stateNr)}', file=self.outfile, end='')
 			next_visited = next_state in self.visited
 
 			if self.elabel is None:
 				print(f' -> ', file=self.outfile, end='')
 			else:
-				label = str(self.elabel(graph, stateNr, next_state)).replace('"', '""')
+				label = str(self.elabel(edge)).replace('"', '""')
 				print(f' ->["{label}"] ', file=self.outfile, end='')
 
 			print(f'{self.printState(graph, next_state)};', file=self.outfile)