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

umaudemc/__main__.py

@@ -206,6 +206,11 @@ def build_parser():
 		help='probability assignment method for adding them to the graph',
 		metavar='METHOD'
 	)
+	parser_graph.add_argument(
+		'-k', '--kleene-iteration',
+		help='write annotations on the transitions starting and terminating an iteration',
+		action='store_true'
+	)
 	parser_graph.set_defaults(mode='graph')
 
 	#

umaudemc/api.py

@@ -297,7 +297,7 @@ class MaudeModel:
 				wgraph = _wrappers.BoundedGraph(self.graph, depth) if depth > 0 else self.graph
 
 				# Create and store the wrapped graph
-				wgraph = _wrappers.wrapGraph(wgraph, purge, merge)
+				wgraph = _wrappers.wrap_graph(wgraph, purge, merge)
 				self.wgraphs[(purge, merge, depth > 0)] = wgraph
 
 				# In case both purge and merge are used, we keep the purged

umaudemc/backend/_spot.py

@@ -8,7 +8,6 @@ import buddy
 import spot
 
 from ..formulae import collect_aprops
-from ..opsem import OpSemKleeneInstance, OpSemGraph
 from ..wrappers import create_graph
 
 
@@ -136,9 +135,10 @@ class KleeneModelBuilder(SpotModelBuilder):
 	"""Generator of ω-automata for strategy-controlled models with an iteration like the Kleene star"""
 
 	def __init__(self, module, initial, strategy, aprops, bdd_dict, metamodule=None, opaques=()):
-		self.instance = OpSemKleeneInstance.make_instance(module, metamodule)
+		from ..kleene import get_kleene_graph_mts
 
-		super().__init__(self.instance.make_graph(initial, strategy, opaques), aprops, bdd_dict)
+		# opaque strategies are ignored with the new implementation
+		super().__init__(get_kleene_graph_mts(module, initial, strategy), aprops, bdd_dict)
 
 		# Table of distinct iterations (from their context to the index of
 		# its accepting condition)
@@ -166,7 +166,7 @@ class KleeneModelBuilder(SpotModelBuilder):
 			state = pending.pop()
 			state_spot = self.state_map[state]
 
-			for next_state in self.graph.getNextStates(state):
+			for next_state, edge in self.graph.getTransitions(state):
 				next_state_spot = self.state_map.get(next_state)
 
 				if next_state_spot is None:
@@ -175,10 +175,10 @@ class KleeneModelBuilder(SpotModelBuilder):
 					pending.append(next_state)
 
 				# Check the iteration tags and set the accepting labels of the edges
-				next_state_term = self.instance.get_cterm(self.graph.getStateTerm(next_state))
+				next_state_term = self.graph.getStateTerm(next_state)
 				acc_set = []
 
-				for tag, enter in self.instance.extract_tags(self.graph.getStateTerm(next_state)):
+				for tag, enter in edge.iterations:
 					acc_index = self.iter_map.get(tag)
 
 					if acc_index is None:
@@ -299,7 +299,6 @@ class SpotBackend:
 			stats['counterexample'] = model_builder.extract_counterexample(run, model_automaton)
 
 		if get_graph:
-			stats['graph'] = model_builder.graph if not kleene_iteration \
-				else OpSemGraph(model_builder.graph, model_builder.instance)
+			stats['graph'] = model_builder.graph
 
 		return holds, stats

umaudemc/command/acheck.py

@@ -0,0 +1,21 @@
+#
+# Admissibility checking subcommand
+#
+
+import os
+
+from ..common import parse_initial_data, usermsgs
+# Meter las herramientas en backends y usar la misma estrategia que en otros contextos
+
+def acheck(args):
+	"""Admissibility check subcommand"""
+
+	# Parse the module data
+	data = parse_initial_data(args, only_module=True)
+
+	if data is None:
+		return 1
+
+	print(data.module)
+
+	return 0

umaudemc/command/graph.py

@@ -11,7 +11,7 @@ from shutil import which
 from ..common import maude, usermsgs, default_model_settings, parse_initial_data, split_comma
 from ..formatter import get_formatters
 from ..grapher import DOTGrapher, PDOTGrapher, TikZGrapher
-from ..wrappers import wrapGraph
+from ..wrappers import wrap_graph
 
 
 class ProcessStream:
@@ -96,6 +96,18 @@ def graph(args):
 	                                                   args.merge_states,
 	                                                   args.strategy)
 
+	# Check the Kleene iteration flag
+	kleene_graph = False
+
+	if args.kleene_iteration:
+		if not with_strategy:
+			usermsgs.print_warning('The --kleene-iteration flag should only be used with a strategy. Ignoring.')
+		elif args.passign:
+			usermsgs.print_warning('The --kleene-iteration flag cannot be used with probabilities. Ignoring.')
+		else:
+			kleene_graph = True
+
+
 	# Select the appropriate rewriting graph
 	# (probabilistic, strategy-controlled, or standard)
 	if args.passign or oformat in ('prism', 'jani'):
@@ -106,13 +118,18 @@ def graph(args):
 		                                  purge_fails=args.purge_fails,
 		                                  merge_states=args.merge_states)
 
+	elif kleene_graph:
+		from ..kleene import get_kleene_graph
+		rwgraph = get_kleene_graph(initial_data)
+		rwgraph = wrap_graph(rwgraph, purge_fails, merge_states)
+
 	elif not with_strategy:
 		rwgraph = maude.RewriteGraph(initial_data.term)
 
 	else:
 		rwgraph = maude.StrategyRewriteGraph(initial_data.term, initial_data.strategy,
 		                                     initial_data.opaque, initial_data.full_matchrew)
-		rwgraph = wrapGraph(rwgraph, purge_fails, merge_states)
+		rwgraph = wrap_graph(rwgraph, purge_fails, merge_states)
 
 	# If something has failed when creating the graph
 	if rwgraph is None:
@@ -129,8 +146,19 @@ def graph(args):
 	else:
 		aprops = []
 
+	# State and edge labels
 	slabel, elabel = get_formatters(args.slabel, args.elabel, with_strategy, only_labels=True)
 
+	if kleene_graph:
+		# Extend the label with the iteration flags
+		original_elabel = elabel
+
+		def kleene_elabel(stmt):
+			iterations_txt = ''.join(f'{" +" if enter else " -"}{iid}' for iid, enter in stmt.iterations)
+			return f'{original_elabel(stmt)}{iterations_txt}'
+
+		elabel = kleene_elabel
+
 	# Whether the graph should be seen as a CTMC and probabilities should not be normalized
 	is_ctmc = args.passign and args.passign.startswith('ctmc-')
 

umaudemc/common.py

@@ -14,30 +14,6 @@ from . import usermsgs
 # Warn about old versions of the maude package installed
 #
 
-if hasattr(maude, 'StateTransitionGraph'):
-	usermsgs.print_warning('Version 0.3 of the maude package contains bugs related to model checking.\n'
-	                       'Please update.')
-
-	# Anyhow, allow using it at their own risk, for which some adaptations are needed
-	maude.RewriteGraph = maude.StateTransitionGraph
-	maude.StrategyRewriteGraph = maude.StrategyTransitionGraph
-
-	maude.Symbol.__call__ = lambda self, *args: self.makeTerm(args)
-
-if not hasattr(maude, 'Hook'):
-	usermsgs.print_warning('Version 0.5 of the maude package adds some useful features for this program.\n'
-	                       'Please update.')
-
-	maude.RewriteGraph.getNrRewrites = lambda: 0
-	maude.StrategyRewriteGraph.getNrRewrites = lambda: 0
-	maude.ModelCheckResult.nrBuchiStates = 0
-	maude.downModule = lambda term: term.symbol().getModule().downModule(term)
-	maude.Sort.__le__ = lambda self, other: self.leq(other)
-	maude.Term.__eq__ = lambda self, other: self.equal(other)
-
-if not hasattr(maude.StrategyRewriteGraph, 'getNrRealStates'):
-	maude.StrategyRewriteGraph.getNrRealStates = maude.StrategyRewriteGraph.getNrStates
-
 if not hasattr(maude.Term, 'getVarName'):
 	usermsgs.print_warning('Version 1.0 of the maude package adds some useful features for this program.\n'
 	                       'Please update.')

umaudemc/counterprint.py

@@ -78,17 +78,21 @@ def print_counterexample(graph, counter, printer_triple):
 		next_index = lead_in[i+1] if i+1 < len(lead_in) else cycle[0]
 
 		if graph.strategyControlled:
+			trans = graph.getTransition(index, next_index)
+
 			printer.next_step_strat(
 				sformat(graph, index),
 				graph.getStateStrategy(index),
-				eformat(graph, index, next_index),
+				eformat(trans),
 				sformat(graph, next_index),
 				first_index=index,
 				second_index=next_index)
 		else:
+			rule = graph.getRule(index, next_index)
+
 			printer.next_step(
 				sformat(graph, index),
-				eformat(graph, index, next_index),
+				eformat(rule),
 				sformat(graph, next_index),
 				first_index=index,
 				second_index=next_index)
@@ -103,17 +107,21 @@ def print_counterexample(graph, counter, printer_triple):
 		next_index = cycle[i+1] if i+1 < len(cycle) else cycle[0]
 
 		if graph.strategyControlled:
+			trans = graph.getTransition(index, next_index)
+
 			printer.next_step_strat(
 				sformat(graph, index),
 				graph.getStateStrategy(index),
-				eformat(graph, index, next_index),
+				eformat(trans),
 				sformat(graph, next_index),
 				first_index=index,
 				second_index=next_index)
 		else:
+			rule = graph.getRule(index, next_index)
+
 			printer.next_step(
 				sformat(graph, index),
-				eformat(graph, index, next_index),
+				eformat(rule),
 				sformat(graph, next_index),
 				first_index=index,
 				second_index=next_index)

umaudemc/data/smcview.js

@@ -38,13 +38,11 @@ function browseDir(dir)
 		}
 	}
 
-	var question = new FormData()
-
-	question.append('question', 'ls')
-	question.append('url', dir)
+	var question = {question: 'ls', url: dir}
 
 	request.open('post', 'ask')
-	request.send(question)
+	request.setRequestHeader('Content-Type', 'application/json')
+	request.send(JSON.stringify(question))
 }
 
 function openFile(file)
@@ -57,6 +55,23 @@ function openFile(file)
 	loadSourceModules(file)
 }
 
+function loadSourceNative()
+{
+	const request = new XMLHttpRequest()
+
+	request.onreadystatechange = function()
+	{
+		if (this.readyState == XMLHttpRequest.DONE && this.status == 200)
+		{
+			console.log(this.responseText)
+			openFile(this.responseText)
+		}
+	}
+
+	request.open('get', 'umaudemc://open/')
+	request.send()
+}
+
 function incompletePassign()
 {
 	switch (document.getElementById('pmethod').value) {
@@ -193,11 +208,10 @@ function loadSourceModules(file)
 	// Discard modules from previous files
 	smodule.options.length = 0
 
-	var question = new FormData()
-	question.append('question', 'sourceinfo')
-	question.append('url', file)
+	var question = {question: 'sourceinfo', url: file}
 	request.open('post', 'ask')
-	request.send(question)
+	request.setRequestHeader('Content-Type', 'application/json')
+	request.send(JSON.stringify(question))
 }
 
 function addPropToFormula(prop)
@@ -318,11 +332,11 @@ function loadModule()
 
 	description.innerText = 'Please select a Maude file and a Maude module defining the system and properties specification.'
 
-	var question = new FormData()
-	question.append('question', 'modinfo')
-	question.append('mod', currentModule)
+	var question = {question: 'modinfo', mod: currentModule}
+
 	request.open('post', 'ask')
-	request.send(question)
+	request.setRequestHeader('Content-Type', 'application/json')
+	request.send(JSON.stringify(question))
 }
 
 function modelcheck()
@@ -356,14 +370,14 @@ function modelcheck()
 		}
 	}
 
-	var question = new FormData()
-
-	question.append('question', 'modelcheck')
-	question.append('mod', document.getElementById('module').value)
-	question.append('initial', document.getElementById('initial').value)
-	question.append('formula', document.getElementById('formula').value)
-	question.append('strategy', document.getElementById('strategy').value)
-	question.append('opaques', document.getElementById('opaques').value)
+	const question = {
+		question: 'modelcheck',
+		mod: document.getElementById('module').value,
+		initial: document.getElementById('initial').value,
+		formula: document.getElementById('formula').value,
+		strategy: document.getElementById('strategy').value,
+		opaques: document.getElementById('opaques').value
+	}
 
 	// Quantitative model checking stuff
 	if (document.getElementById('command').value == 'qt')
@@ -375,7 +389,8 @@ function modelcheck()
 	}
 
 	request.open('post', 'ask')
-	request.send(question)
+	request.setRequestHeader('Content-Type', 'application/json')
+	request.send(JSON.stringify(question))
 }
 
 function escapeHTMLChars(text) {
@@ -460,17 +475,15 @@ function waitModelChecker(mcref) {
 	// Disable input until model checking has finished
 	disableInput(true)
 
-	var question = new FormData()
+	const question = {question: 'wait', mcref: mcref}
 
-	question.append('question', 'wait')
-	question.append('mcref', mcref)
 	request.open('post', 'ask')
-	request.send(question)
+	request.setRequestHeader('Content-Type', 'application/json')
+	request.send(JSON.stringify(question))
 }
 
 function cancelChecking() {
 	const request = new XMLHttpRequest()
-	const question = new FormData()
 
 	request.onreadystatechange = function()
 	{
@@ -486,9 +499,9 @@ function cancelChecking() {
 		}
 	}
 
-	question.append('question', 'cancel')
 	request.open('post', 'ask')
-	request.send(question)
+	request.setRequestHeader('Content-Type', 'application/json')
+	request.send('{"question": "cancel"}')
 }
 
 function closeResultDialog()

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/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)