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

umaudemc/__init__.py

@@ -1 +1 @@
-__version__ = '0.12.2'
+__version__ = '0.14.0'

umaudemc/backend/_stormpy.py

@@ -80,7 +80,7 @@ class StormBackend:
 			builder.add_next_value(row=st, column=st, value=1.0)
 
 	def _build_mdp(self, builder, graph):
-		"""Build an MDP from the probabilsitic rewrite graph"""
+		"""Build an MDP from the probabilistic rewrite graph"""
 
 		last_visited, row_index, num_states = -1, 0, len(graph)
 
@@ -127,7 +127,6 @@ class StormBackend:
 			self._build_mdp(builder, graph)
 
 		transition_matrix = builder.build()
-		#input(transition_matrix)
 
 		# State labeling with atomic propositions
 		state_labeling = stormpy.storage.StateLabeling(num_states)
@@ -233,7 +232,7 @@ class StormBackend:
 	def state_analysis(self, *args, **kwargs):
 		"""Steady and transient state analysis"""
 
-		# StormPy does not allow calculting state probabilities, as far as we know, so
+		# StormPy does not allow calculating state probabilities, as far as we know, so
 		# we delegate on the command-line interface to Storm
 		from ._storm import StormBackend as StormCmdLineBackend
 

umaudemc/backend/bmcalc.py

@@ -479,22 +479,22 @@ class BuiltinBackend:
 			return [modop, self.ctl2mucalc(rest[0], index=index)]
 		elif head == '_U_':
 			return ['mu_._', ['Var', f'Z{index}'], ['_\\/_',
-				  self.ctl2mucalc(rest[1], index=index + 1),
-				  ['_/\\_', self.ctl2mucalc(rest[0], index=index + 1),
-				  [modop, ['Var', f'Z{index}']]]]]
+			                                        self.ctl2mucalc(rest[1], index=index + 1),
+			                                        ['_/\\_', self.ctl2mucalc(rest[0], index=index + 1),
+			                                         [modop, ['Var', f'Z{index}']]]]]
 		elif head == '_R_':
 			return ['nu_._', ['Var', f'Z{index}'], ['_/\\_',
-				  self.ctl2mucalc(rest[1], index=index + 1),
-				  ['_\\/_', self.ctl2mucalc(rest[0], index=index + 1),
-				  [modop, ['Var', f'Z{index}']]]]]
+			                                        self.ctl2mucalc(rest[1], index=index + 1),
+			                                        ['_\\/_', self.ctl2mucalc(rest[0], index=index + 1),
+			                                         [modop, ['Var', f'Z{index}']]]]]
 		elif head == '`[`]_':
 			return ['nu_._', ['Var', f'Z{index}'], ['_/\\_',
-				  self.ctl2mucalc(rest[0], index=index + 1),
-				  [modop, ['Var', f'Z{index}']]]]
+			                                        self.ctl2mucalc(rest[0], index=index + 1),
+			                                        [modop, ['Var', f'Z{index}']]]]
 		elif head == '<>_':
 			return ['mu_._', ['Var', f'Z{index}'], ['_\\/_',
-				  self.ctl2mucalc(rest[0], index=index + 1),
-				  [modop, ['Var', f'Z{index}']]]]
+			                                        self.ctl2mucalc(rest[0], index=index + 1),
+			                                        [modop, ['Var', f'Z{index}']]]]
 		else:
 			return [head] + [self.ctl2mucalc(arg, index=index) for arg in rest]
 

umaudemc/backend/ltsmin.py

@@ -552,7 +552,7 @@ class LTSminRunner:
 		maude_lib_ltsmin = os.getenv('MAUDE_LIB_LTSMIN')
 		new_maude_lib = os.getenv('MAUDE_LIB', '') if maude_lib_ltsmin is None else maude_lib_ltsmin
 		new_maude_lib = ('' if new_maude_lib == '' else new_maude_lib + os.pathsep) \
-		                + os.path.dirname(filename)
+		                 + os.path.dirname(filename)
 
 		if raw:
 			os.execve(self.ltsmin.pins2lts[variant], [self.ltsmin.pins2lts[variant]] + args,

umaudemc/command/check.py

@@ -8,7 +8,7 @@ import sys
 import tempfile
 
 from ..common import parse_initial_data, usermsgs
-from ..backends import kleene_backends, get_backends, backend_for, format_statistics,\
+from ..backends import kleene_backends, get_backends, backend_for, format_statistics, \
 	advance_counterexample, advance_kleene
 from ..counterprint import SimplePrinter, JSONPrinter, HTMLPrinter, DOTPrinter, print_counterexample
 from ..formulae import Parser, collect_aprops, add_path_premise, formula_list2str

umaudemc/command/graph.py

@@ -71,7 +71,7 @@ def deduce_format(args):
 		usermsgs.print_warning('PDF output is only supported with DOT. Changing to DOT.')
 		return 'dot'
 
-	# Probabilitic information is not considered in some cases
+	# Probabilistic information is not considered in some cases
 	if args.passign and oformat not in ('dot', 'prism', 'jani', 'default'):
 		usermsgs.print_warning('Probabilistic graphs are only supported with PRISM, JANI and DOT output. '
 		                       'Ignoring probabilities.')
@@ -107,7 +107,6 @@ def graph(args):
 		else:
 			kleene_graph = True
 
-
 	# Select the appropriate rewriting graph
 	# (probabilistic, strategy-controlled, or standard)
 	if args.passign or oformat in ('prism', 'jani'):

umaudemc/command/pcheck.py

@@ -50,6 +50,7 @@ def _print_fraction(value):
 
 	return f'{num}/{den}' if num > 0 and den != 1 else num
 
+
 def _select_backend(known_backends, backend_list):
 	"""Get the first available backend according to the user preferences"""
 
@@ -78,7 +79,6 @@ def _select_backend(known_backends, backend_list):
 		elif first_known is None:
 			first_known = name
 
-
 	if first_available is None:
 		if first_known is None:
 			usermsgs.print_error('The backend list does not contain any valid option.')

umaudemc/command/test.py

@@ -280,7 +280,7 @@ def _depends_on_vars(node, variables):
 
 
 class ParameterSet:
-	"""Assignement to parameters to be replaced on test attributes"""
+	"""Assignment to parameters to be replaced on test attributes"""
 
 	def __init__(self, dic, is_subs=None):
 		# Dictionary with the parameter assignments

umaudemc/common.py

@@ -18,7 +18,8 @@ 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.')
 
-	maude.Term.getVarName = lambda self: str(self).split(':')[0] if self.symbol() == self.symbol().getModule().parseTerm(f'$$$:{self.getSort()}').symbol() else None
+	maude.Term.getVarName = lambda self: str(self).split(':')[0] if self.symbol() == \
+		self.symbol().getModule().parseTerm(f'$$$:{self.getSort()}').symbol() else None
 	maude.Term.isVariable = lambda self: self.getVarName() is None
 
 

umaudemc/data/select.htm

@@ -85,7 +85,7 @@
 				<option value="metadata">Weighted by metadata</option>
 				<option value="strategy">Probabilistic strategy</option>
 			</select>
-			<input type="checkbox" id="mdp" style="margin-left: 1.5ex; display: none;"></input>
+			<input type="checkbox" id="mdp" style="margin-left: 1.5ex; display: none;"/>
 			<label for="mdp" style="display: none;">MDP</label>
 			<label for="parg" style="margin-left: 1.5ex; display: none;">Weight term:</label>
 			<input type="text" id="parg" style="flex-grow: 1; display: none;" onchange="buttonToggle()"

umaudemc/formatter.py

@@ -19,7 +19,7 @@ def apply_state_format(graph, index, sformat, terms, use_term=False, use_strat=F
 	:type sformat: str
 	:param terms: Term patterns to appear in the format string.
 	:type terms: list of string
-	:param use_term: Whether the term is actually used (only for effiency).
+	:param use_term: Whether the term is actually used (only for efficiency).
 	:type use_term: bool
 	:param use_strat: Whether the strategy is actually used (only for effiency).
 	:type use_strat: bool

umaudemc/opsem.py

@@ -65,7 +65,7 @@ class OpSemInstance:
 
 	@classmethod
 	def get_instantiation(cls, module, metamodule=None, semantics_module=None, preds_module=None):
-		"""Get the Maude code to instantiate the sematnics for the given problem"""
+		"""Get the Maude code to instantiate the semantics for the given problem"""
 
 		# Use the default semantics and predicates module if not specified
 		if semantics_module is None:

umaudemc/probabilistic.py

@@ -714,7 +714,7 @@ class GeneralizedMetadataGraph:
 			edges = []
 
 			for child, subs, ctx, rl in term.apply(None):
-				# Term.apply do not reduce the terms itself
+				# Term.apply does not reduce the terms itself
 				self.rewrite_count += 1 + child.reduce()
 				index = self.term_map.get(child)
 

umaudemc/pyslang.py

@@ -30,7 +30,7 @@ class Instruction:
 	RWCSTART = 11  # list of (pattern, condition, starting pattern)
 	RWCNEXT = 12  # list of (end pattern, condition, starting pattern/right-hand side)
 	NOTIFY = 13  # list of lists of variables of the nested pending matchrew subterms
-	SAMPLE = 14  # (variable, distribution callable, its arguments)
+	SAMPLE = 14  # (variable, distribution sampler, distribution generator, its arguments)
 	WMATCHREW = 15  # like MATCHREW + (weight)
 	ONE = 16  # no arguments
 	CHECKPOINT = 17  # no arguments
@@ -130,12 +130,30 @@ def merge_substitutions(sb1, sb2):
 	return maude.Substitution({**dict(sb1), **dict(sb2)})
 
 
-def bernoulli_distrib(p):
-	"""Bernoulli distribution"""
+def bernoulli_sampler(p):
+	"""Bernoulli distribution sampler"""
 
 	return 1.0 if random.random() < p else 0.0
 
 
+def bernoulli_distribution(p):
+	"""Explicit Bernoulli distribution"""
+
+	return (p, 1.0), (1 - p, 0.0)
+
+
+def uniform_sampler(start, end):
+	"""Integer uniform distribution sampler"""
+
+	return random.randint(start, end + 1)
+
+
+def uniform_distribution(start, end):
+	"""Explicit uniform distribution"""
+
+	return ((1, k) for k in range(start, end + 1))
+
+
 def find_cycles(initial, next_fn):
 	"""Find cycles in the graph and return the points where to cut them"""
 
@@ -290,6 +308,9 @@ class StratCompiler:
 		self.mtc_symbol = ml.findSymbol('_:=_', (term_kind, term_kind), condition_kind)
 		self.stc_symbol = ml.findSymbol('_:_', (term_kind, term_kind), condition_kind)
 
+		# Kind of natural numbers (if any)
+		self.nat_kind = self.get_special_kind('ACU_NumberOpSymbol')
+
 		# Program counters of the generated strategy calls
 		self.calls = []
 
@@ -311,6 +332,13 @@ class StratCompiler:
 
 		return list(term.arguments())
 
+	def get_special_kind(self, hook):
+		"""Get a special kind by the hook name of one of its symbols"""
+
+		for s in self.m.getSymbols():
+			if (id_hooks := s.getIdHooks()) and id_hooks[0][0] == hook:
+				return s.getRangeSort().kind()
+
 	def substitution2dict(self, substitution):
 		"""Convert a metalevel substitution to a dictionary"""
 
@@ -670,15 +698,26 @@ class StratCompiler:
 		name = str(name)[1:]
 		args = tuple(map(self.m.downTerm, self.get_list(args, self.empty_term_list, self.term_list_symbol)))
 
-		name = {
-			'bernoulli': bernoulli_distrib,
-			'uniform': random.uniform,
+		# Whether the distribution is discrete
+		discrete = name == 'bernoulli' or (name == 'uniform' and self.nat_kind is not None
+			and all(arg.getSort().kind() == self.nat_kind for arg in args))
+
+		# Sampler to obtain one value from the distribution
+		sampler = {
+			'bernoulli': bernoulli_sampler,
+			'uniform': uniform_sampler if discrete else random.uniform,
 			'exp': random.expovariate,
 			'norm': random.normalvariate,
 			'gamma': random.gammavariate,
 		}[name]
 
-		p.append(Instruction.SAMPLE, (self.m.downTerm(variable), name, args))
+		# Full distribution generator (for graph generation in discrete distributions)
+		generator = None
+
+		if discrete:
+			generator = bernoulli_distribution if name == 'bernoulli' else uniform_distribution
+
+		p.append(Instruction.SAMPLE, (self.m.downTerm(variable), sampler, generator, args))
 		self.generate(strat, p, tail)
 		p.append(Instruction.POP)
 
@@ -1478,6 +1517,9 @@ class StratRunner:
 		elif stack.pc:
 			self.current_state.pc = stack.pc
 
+		else:
+			self.current_state.pc += 1
+
 		# Pop the stack node
 		if stack.parent:
 			self.current_state.stack = self.current_state.stack.parent
@@ -1835,10 +1877,10 @@ class StratRunner:
 
 		self.next_pending()
 
-	def sample(self, args, stack):
-		"""Sample a probability distribution into a variable"""
+	def sample_get_params(self, args, stack):
+		"""Extract distribution parameters from a sample call"""
 
-		variable, dist, dargs = args
+		_, _, generator, dargs = args
 
 		# Arguments of the distribution instantiated in the variable context
 		dargs = [(stack.venv.instantiate(arg) if stack.venv else arg) for arg in dargs]
@@ -1847,9 +1889,20 @@ class StratRunner:
 		for arg in dargs:
 			self.nr_rewrites += arg.reduce()
 
-		dargs = [float(arg) for arg in dargs]
+		# Argument type to convert arguments
+		atype = float if generator is not uniform_distribution else int
+
+		return [atype(arg) for arg in dargs]
+
+	def sample(self, args, stack):
+		"""Sample a probability distribution into a variable"""
+
+		variable, sampler, _, dargs = args
+
+		dargs = self.sample_get_params(args, stack)
 
-		new_variable = {variable: variable.symbol().getModule().parseTerm(str(dist(*dargs)))}
+		module = variable.symbol().getModule()
+		new_variable = {variable: module.parseTerm(str(sampler(*dargs)))}
 
 		self.current_state.pc += 1
 		self.current_state.stack = StackNode(parent=self.current_state.stack,
@@ -1963,7 +2016,7 @@ class GraphState:
 
 
 class BadProbStrategy(Exception):
-	"""Bad probabilitistic strategy that cannot engender MDPs or DTMCs"""
+	"""Bad probabilistic strategy that cannot engender MDPs or DTMCs"""
 
 	def __init__(self):
 		super().__init__('Strategies are not allowed to make nondeterministic choices '
@@ -2001,7 +2054,7 @@ class GraphRunner(StratRunner):
 
 		# Solution states, indexed by term (we introduce them as children
 		# of graph states where both a solution of the strategy and a
-		# different sucessor can be reached)
+		# different successor can be reached)
 		self.solution_states = {}
 
 	def get_solution_state(self, term):
@@ -2081,9 +2134,12 @@ class GraphRunner(StratRunner):
 		"""Return from a strategy call or similar construct"""
 
 		# Return from a strategy call
-		if stack.pc:
+		if stack.pc is not None:
 			self.current_state.pc = stack.pc
 
+		else:
+			self.current_state.pc += 1
+
 		# Actually pop the stack node
 		if stack.parent:
 			self.current_state.stack = self.current_state.stack.parent
@@ -2189,6 +2245,27 @@ class GraphRunner(StratRunner):
 
 		self.next_pending()
 
+	def sample(self, args, stack):
+		variable, sampler, generator, dargs = args
+
+		# Only special behavior for discrete distributions
+		if not generator:
+			return super().sample(args, stack)
+
+		# Arguments of the distribution instantiated in the variable context
+		dargs = self.sample_get_params(args, stack)
+
+		# Generate a pending state for each possible outcome
+		module = variable.symbol().getModule()
+
+		for _, value in generator(*dargs):
+			self.pending.append(self.current_state.copy(stack=StackNode(
+				parent=self.current_state.stack,
+				venv=merge_substitutions(stack.venv, {variable: module.parseTerm(str(value))})))
+			)
+
+		self.next_pending()
+
 	def run(self):
 		"""Run the strategy to generate the graph"""
 
@@ -2298,20 +2375,8 @@ class MarkovRunner(GraphRunner):
 
 		graph_state.child_choices = tuple(new_choices)
 
-	def choice(self, args, stack):
-		"""A choice node"""
-
-		weights, targets = zip(*args)
-		weights = list(self.compute_weights(weights, stack.venv))
-
-		# Remove options with null weight
-		targets = [target for k, target in enumerate(targets) if weights[k] != 0.0]
-		weights = [w for w in weights if w != 0.0]
-
-		# If there is only a positive weight, we can proceed with it
-		if len(weights) == 1:
-			self.current_state.pc = targets[0]
-			return
+	def spawn_choice(self, weights, new_xss):
+		"""Spawn tasks for a choice"""
 
 		# Otherwise, if there is at least one
 		if weights:
@@ -2323,8 +2388,7 @@ class MarkovRunner(GraphRunner):
 			# These graph states cannot be pushed to the DFS stack (because we
 			# are not exploring them yet), they should be pushed when the
 			# execution state new_xs is executed, so we add them to push_state
-			for k, target in enumerate(targets):
-				new_xs = self.current_state.copy(pc=target)
+			for k, new_xs in enumerate(new_xss):
 				self.pending.append(new_xs)
 				self.push_state[new_xs] = new_states[k]
 
@@ -2333,6 +2397,26 @@ class MarkovRunner(GraphRunner):
 
 		self.next_pending()
 
+	def choice(self, args, stack):
+		"""A choice node"""
+
+		weights, targets = zip(*args)
+		weights = list(self.compute_weights(weights, stack.venv))
+
+		# Remove options with null weight
+		targets = [target for k, target in enumerate(targets) if weights[k] != 0.0]
+		weights = [w for w in weights if w != 0.0]
+
+		# If there is only a positive weight, we can proceed with it
+		if len(weights) == 1:
+			self.current_state.pc = targets[0]
+			return
+
+		# New execution states
+		new_xss = (self.current_state.copy(pc=target) for target in targets)
+
+		self.spawn_choice(weights, new_xss)
+
 	def wmatchrew(self, args, stack):
 		"""A matchrew with weight node"""
 
@@ -2376,24 +2460,34 @@ class MarkovRunner(GraphRunner):
 			self.current_state = new_xss[0]
 			return
 
-		# Otherwise, if there is at least one
-		if weights:
-			graph_state = self.dfs_stack[-1]
+		self.spawn_choice(weights, new_xss)
 
-			# Create a new graph state (without term) for each branch of the matchrew
-			new_states = [self.GraphState(None) for _ in range(len(weights))]
+	def sample(self, args, stack):
+		variable, sampler, generator, dargs = args
 
-			# These graph states cannot be pushed to the DFS stack (because we
-			# are not exploring them yet), they should be pushed when the
-			# execution state new_xss[k] is executed, so we add them to push_state
-			for k in range(len(targets)):
-				self.pending.append(new_xss[k])
-				self.push_state[new_xss[k]] = new_states[k]
+		# Only a special behavior for discrete distributions
+		if not generator:
+			return super().sample(args, stack)
 
-			# Add the resolved choice to the graph state
-			graph_state.child_choices.add(tuple(zip(weights, new_states)))
+		# Arguments of the distribution instantiated in the variable context
+		dargs = self.sample_get_params(args, stack)
 
-		self.next_pending()
+		# Generate the distribution of options
+		module = variable.symbol().getModule()
+		weights, new_xss = [], []
+
+		for weight, value in generator(*dargs):
+			weights.append(weight)
+			new_xss.append(self.current_state.copy(stack=StackNode(
+				parent=self.current_state.stack,
+				venv=merge_substitutions(stack.venv, {variable: module.parseTerm(str(value))})
+			)))
+
+		# If there is only a positive weight, we can proceed with it
+		if len(weights) == 1:
+			self.current_state = new_xss[0]
+
+		self.spawn_choice(weights, new_xss)
 
 	def notify(self, args, stack):
 		"""Record a transition in the graph"""
@@ -2594,6 +2688,9 @@ class RandomRunner(StratRunner):
 		if stack.pc:
 			self.current_state.pc = stack.pc
 
+		else:
+			self.current_state.pc += 1
+
 		# Pop the stack node
 		if stack.parent:
 			self.current_state.stack = self.current_state.stack.parent

umaudemc/quatex.py

@@ -458,8 +458,8 @@ class QuaTExParser:
 						self.ok = False
 
 					slot = self.fslots.setdefault(call_name, len(self.fslots))
-					current = ast.Tuple([ast.Constant(inside_next), ast.Constant(slot), *args],
-					                    ast.Load(), custom_loc=(call_line, call_column))
+					current = ast.Tuple([ast.Constant(inside_next), ast.Constant(slot), *args], ast.Load())
+					current.custom_loc = (call_line, call_column)
 					self.calls.append((call_name, call_line, call_column, len(args)))
 					inside_next = False
 					call_name = None

umaudemc/resources.py

@@ -3,45 +3,31 @@
 #
 # These are included in the package tree and they should be loaded
 # even if the package is distributed as a compressed archive. This is
-# possible with importlib.resources in 3.7 and its backport
-# importlib_resources in previous versions.
+# possible with importlib.resources.
 #
 
-import sys
 import importlib.resources as pkg_resources
 
 from . import data  # Import the data directory as a package
 
-# To avoid deprecation warnings in Python 3.11 and above
-if sys.version_info >= (3, 9):
-	
-	def get_resource_path(name):
-		"""Get a temporary filename for a given named resource"""
-		return pkg_resources.as_file(pkg_resources.files(data) / name)
+# Root for static resources
+_DATA_ROOT = pkg_resources.files(data)
 
-	def get_resource_content(name):
-		"""Get the string content of a given named resource"""
-		return (pkg_resources.files(data) / name).read_text()
 
-	def get_resource_binary(name):
-		"""Get the string content of a given named resource"""
-		return (pkg_resources.files(data) / name).read_bytes()
+def get_resource_path(name):
+	"""Get a temporary filename for a given named resource"""
+	return pkg_resources.as_file(_DATA_ROOT / name)
 
-# For compatibility with Python 3.8
-else:
-	def get_resource_path(name):
-		"""Get a temporary filename for a given named resource"""
-		return pkg_resources.path(data, name)
 
+def get_resource_content(name):
+	"""Get the string content of a given named resource"""
+	return (_DATA_ROOT / name).read_text()
 
-	def get_resource_content(name):
-		"""Get the string content of a given named resource"""
-		return pkg_resources.read_text(data, name)
 
+def get_resource_binary(name):
+	"""Get the string content of a given named resource"""
+	return (_DATA_ROOT / name).read_bytes()
 
-	def get_resource_binary(name):
-		"""Get the string content of a given named resource"""
-		return pkg_resources.read_binary(data, name)
 
 def get_templog():
 	"""Get a temporary filename for the templog Maude file"""

umaudemc/simulators.py

@@ -79,8 +79,9 @@ class BaseSimulator:
 		if not t:
 			t, var = parse_hole_term(self.module, observation)
 			self.obs_cache[observation] = (t, var)
-		subs = maude.Substitution({var: self.state})
-		t = subs.instantiate(t)
+		if var is not None:
+			subs = maude.Substitution({var: self.state})
+			t = subs.instantiate(t)
 		t.reduce()
 
 		return float(t == self.true) if t.getSort() == self.bool_sort else float(t)

umaudemc/statistical.py

@@ -221,6 +221,7 @@ def thread_main(program, qdata, simulator, num_sims, block_size, seed, queue, ba
 def run_parallel(program, qdata, num_sims, max_sim, simulator, alpha, delta, block_size, jobs, verbose=False):
 	"""Run the simulation in multiple threads"""
 	import multiprocessing as mp
+	mp.set_start_method('fork', force=True)
 
 	# When the number of jobs is zero or negative, we take the CPU count
 	if jobs <= 0:
@@ -232,7 +233,7 @@ def run_parallel(program, qdata, num_sims, max_sim, simulator, alpha, delta, blo
 	# Process communication stuff
 
 	# Random number seeds
-	seeds = [random.randint(0, 1e6) for _ in range(jobs)]
+	seeds = [random.getrandbits(20) for _ in range(jobs)]
 	# Queue for transferring the query evaluations
 	queue = mp.Queue()
 	barrier = mp.Barrier(jobs + 1)
@@ -328,7 +329,7 @@ def check(program, simulator, seed, alpha, delta, block, min_sim, max_sim, jobs,
 	         for idict in make_parameter_dicts(qinfo[2])]
 
 	# Run the simulations
-	if jobs == 1:
+	if jobs == 1 and num_sims != 1:
 		return run_single(program, qdata, num_sims, max_sim, simulator, alpha,
 		                  delta, block, verbose=verbose)
 	else:

umaudemc/webui.py

@@ -142,7 +142,7 @@ class WinPathHandler(PathHandler):
 
 
 class ConnectionInfo:
-	"""Persisent server information"""
+	"""Persistent server information"""
 
 	def __init__(self):
 		self.path_handler = WinPathHandler() if sys.platform == 'win32' else PathHandler()

{umaudemc-0.13.0.dist-info → umaudemc-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: umaudemc
-Version: 0.13.0
+Version: 0.14.0
 Summary: Unified Maude model-checking utility
 Author-email: ningit <ningit@users.noreply.github.com>
 License: GPLv3
@@ -13,18 +13,18 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Topic :: Scientific/Engineering
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: maude >=1.0
+Requires-Dist: maude>=1.0
 Provides-Extra: ctlstar
-Requires-Dist: pyModelChecking >=1.3.3 ; extra == 'ctlstar'
+Requires-Dist: pyModelChecking>=1.3.3; extra == "ctlstar"
+Provides-Extra: yaml
+Requires-Dist: pyaml; extra == "yaml"
 Provides-Extra: plot
-Requires-Dist: matplotlib ; extra == 'plot'
+Requires-Dist: matplotlib; extra == "plot"
 Provides-Extra: smc
-Requires-Dist: scipy ; extra == 'smc'
-Provides-Extra: yaml
-Requires-Dist: pyaml ; extra == 'yaml'
+Requires-Dist: scipy; extra == "smc"
 
 # Unified Maude model-checking tool
 

{umaudemc-0.13.0.dist-info → umaudemc-0.14.0.dist-info}/RECORD

@@ -1,34 +1,34 @@
-umaudemc/__init__.py,sha256=KzYlv9mV5BAclb_b4mb6NprSS8L9Xd0qsNzjQFwnp30,23
+umaudemc/__init__.py,sha256=4pkGIcN2HdoT4OEADiR3LUoE-VfT0mtYYKhwVWEwVMY,23
 umaudemc/__main__.py,sha256=PBIa2mStJwNIK5YnwoCefEB_a59VLkHE_Zp_1hnMyg4,14060
 umaudemc/api.py,sha256=I-o5foy8NUlO4JT4pX9L7kkuHQG_8_GMkWlOKt708E8,19733
 umaudemc/backends.py,sha256=mzJkALYwcKPInT0lBiRsCxJSewKvx5j_akQsqWN1Ezo,4590
-umaudemc/common.py,sha256=5jtR_HLZmTDrZFU2Isd3tJudZdMD-RbkiuHMUA3wPiE,4922
+umaudemc/common.py,sha256=Z1RQNwNpwHApsckHM4Zj5A0ClTuVKKKC1Lkgf9yYmqI,4926
 umaudemc/counterprint.py,sha256=vVqM_UjGRk_xeftFxBGI5m6cQXV7mf8KvbQ_fvAvSQk,9226
-umaudemc/formatter.py,sha256=36l0nc9IIe4B0_eW_PPfDTIxJj0mHKZfddCUugrEyjM,6024
+umaudemc/formatter.py,sha256=nbQlIsR5Xv18OEcpJdnTDGqO9xGL_amvBGFMU2OmheU,6026
 umaudemc/formulae.py,sha256=jZPPDhjgsb7cs5rWvitiQoO0fd8JIlK98at2SN-LzVE,12156
 umaudemc/grapher.py,sha256=K1chKNNlEzQvfOsiFmRPJmd9OpxRIrg6OyiMW6gqOCU,4348
 umaudemc/gtk.py,sha256=61p4_OSFDfNHFD4lLz3QTZ7yZBra3RINmgbcnB-mUis,4249
 umaudemc/jani.py,sha256=N5tE28jZC_OsI041nXOn02THlokpweATtEK-nx9pfWE,4130
 umaudemc/kleene.py,sha256=Yxo9O2rjJNpS6y4Qfb_SP71tDrryV0KKUfmBIKXypwg,4458
 umaudemc/mproc.py,sha256=9X5pTb3Z3XHcdOo8ynH7I5RZQpjzm9xr4IBbEtaglUE,11766
-umaudemc/opsem.py,sha256=p49k8Dto0zJ7jeI8Ih5Q9bB4lqMQaF39kxprlvCMN3U,9448
-umaudemc/probabilistic.py,sha256=f1ZtV84mAuaaGSmYCpun8gaUi5PFGCPD96BUgYvvBGk,29304
-umaudemc/pyslang.py,sha256=m501iqJb4fVlIimpOy_tO7woK5QLkTWYav0no7onoXM,85099
-umaudemc/quatex.py,sha256=HQoiC8N7WnloHPBgNlcpWUi0NcIyUXm3IK_glfHbu4A,21611
-umaudemc/resources.py,sha256=k1sekrTafAcOb7GQN-mx2BgCBEBPUi-IR_4EjNjRRmU,1530
-umaudemc/simulators.py,sha256=gjCWR-TiPeOv65viH-djAkazqaLV0olwfbU6Nak2rdE,13205
-umaudemc/statistical.py,sha256=Az7r4uuB1XrO4akBiYu2th7DSPGzDDAacu6W5wJym-Q,9015
+umaudemc/opsem.py,sha256=Xfdi9QGy-vcpmQ9ni8lBDAlKNw-fCRzYr6wnPbv6m1s,9448
+umaudemc/probabilistic.py,sha256=MNvFeEd84-OYedSnyksZB87UckPfwizVNJepCItgRy8,29306
+umaudemc/pyslang.py,sha256=zOfVGtfnOWDGghtaYLfQHq61KvbzVFmAM_0-upNhrTk,87753
+umaudemc/quatex.py,sha256=sSgGXhHmu_7XqBvcEv7EtGeecZ704OB3B8NFk8XXD00,21600
+umaudemc/resources.py,sha256=qKqvgLYTJVtsQHQMXFObyCLTo6-fssQeu_mG7tvVyD0,932
+umaudemc/simulators.py,sha256=84W30MWWe4QRxK24RGA0zuwXjPya4wH18PrhPKdOpyU,13229
+umaudemc/statistical.py,sha256=-UzP3g4Sy5L_dq2UEimobwu1qR70uEQnqKigsPEvyzU,9074
 umaudemc/terminal.py,sha256=B4GWLyW4Sdymgoavj418y4TI4MnWqNu3JS4BBoSYeTc,1037
 umaudemc/usermsgs.py,sha256=d3RfyBGEBmcV_c2MeXWCtZIiiM2vFnaHsN3MHwMnyAs,583
-umaudemc/webui.py,sha256=7dWf5VVl5dGN9oBVTT8m6F4v_QqEbsKSH67q5FljuT8,11071
+umaudemc/webui.py,sha256=XlDV87tOOdcclHp2_oerrvHwRmCZdqAR4PppqeZm47A,11072
 umaudemc/wrappers.py,sha256=uz9JV1zBVqzkuoByUd569fEcSxT_00aCJw-jcDtrFpE,9399
 umaudemc/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 umaudemc/backend/_pymc.py,sha256=asfN3uc0PbizVTiBt0Hs1n7jxzUN629Baj90z5X8Gjc,6679
 umaudemc/backend/_spot.py,sha256=rwnXJG98kLsjjobeYdFh5RqK07al0bGMzjz2gLnUPOQ,9166
 umaudemc/backend/_storm.py,sha256=yhHPNxLOekr9ZdzZv5Jzv1K6R5hIrYKQ4SES0rds_0A,4675
-umaudemc/backend/_stormpy.py,sha256=KPbRkVYZhwlL007GfbJJc2VBHbBz3_UKqUNM0FV7PyU,8280
-umaudemc/backend/bmcalc.py,sha256=fE6RxIETYu-ywzrwRvWJP5ZZbZXuUbO6TdV4bcJjA6E,17502
-umaudemc/backend/ltsmin.py,sha256=iZNzVQ74oiMOdIv1zNW8oeiLzGO88ENqLfhPQ20i4E0,21103
+umaudemc/backend/_stormpy.py,sha256=gdFFHupp6o-8IEk-NxBaSWFz7zohJWxj27CUdrMNeXg,8253
+umaudemc/backend/bmcalc.py,sha256=cgV11KmvqT-k1TpsdFHJp1bPrY0Wmlh1pG8XkVpO8G4,17874
+umaudemc/backend/ltsmin.py,sha256=5r7o8KTKiQeSW6xSK7sV08rs9l0wb4IOPizJW3T_n1o,21104
 umaudemc/backend/nusmv.py,sha256=ebHWUYv6IcOedD2qsafqyvmEjLaxMmCMBy3tyAfrYUE,10913
 umaudemc/backend/prism.py,sha256=a78MEMXDRD-QRheQIDiAgVKDPyqkQ8iTAWmRE6lsKH4,15502
 umaudemc/backend/pymc.py,sha256=_NXTEpXsf0s5_WE3-1y63jx6iKj2KSjmn8hZZcWMltI,309
@@ -36,24 +36,23 @@ umaudemc/backend/spin.py,sha256=fe5w1YyVQ3LHGiP7jVex5yXC17CwTHlPvM4B3j7kvwk,9663
 umaudemc/backend/spot.py,sha256=P7vkxhY7Tx9J_rOmlua3bfiO8iMgNIuEi25ZNYZRLHk,283
 umaudemc/backend/storm.py,sha256=FlhJ0ZkJO84GjEUxuE2hQQJxJoeE_lElBB5NJL4NXTU,276
 umaudemc/command/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-umaudemc/command/acheck.py,sha256=lEywzcr-yEszvVcEaCELBqN3FJBNpr8C6Xoo8qGWxrU,385
-umaudemc/command/check.py,sha256=fzRUGAHNudZPYFk94ekwKplv9N7Fhsrmf5pOFsvPZwA,12030
-umaudemc/command/graph.py,sha256=74U-yY9NEm5oTeUjspkwy6Ve_eLBTwx8LgZDzUk2LQw,6112
-umaudemc/command/pcheck.py,sha256=RcgwQn8xBgt9eZC1sE3JzR97MB0SC6Q1AXuiKkkzJes,7274
+umaudemc/command/check.py,sha256=PyaPDMw5OnPxSIZ10U4we0b5tTrjnYKAtAeQkJh2uLE,12031
+umaudemc/command/graph.py,sha256=JqGzESC2sn-LBh2sqctrij03ItzwDO808s2qkNKUle0,6112
+umaudemc/command/pcheck.py,sha256=eV4e4GcOHanP4hcIhMKd5Js22_ONac6kYj70FXun3mY,7274
 umaudemc/command/scheck.py,sha256=eRGE-2SsOf6etIfJQ9dJe4cSch8qAs7IuOR94i-E1_U,4653
-umaudemc/command/test.py,sha256=4Uw83V-gVbm21L0Zkv3mKOUpamiNM-qMxGVAYs-trdY,38734
+umaudemc/command/test.py,sha256=kPmV1-hIJMMxZLErqYYP50z95uME_3sLLUMXQuUy9fs,38733
 umaudemc/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 umaudemc/data/opsem.maude,sha256=geDP3_RMgtS1rRmYOybJDCXn_-dyHHxg0JxfYg1ftv0,27929
 umaudemc/data/problog.maude,sha256=qvP90peT3J9gWi7I0x86jfrEXsVxDP5lcrUnSkTMhcY,3091
 umaudemc/data/result.htm,sha256=IwllBM3p4F-QFvOYZZR6bZicL-FuuPLainU9DUPPyNA,1766
-umaudemc/data/select.htm,sha256=g0eXHHFxRpxJ9tqOfSgn_QmSQy0E-ET7MimBllGk6vk,4600
+umaudemc/data/select.htm,sha256=CC9lkczPnLgqxeiSyn2Kv3oxLuuciPjtBzOHfnSv-SE,4593
 umaudemc/data/smcgraph.js,sha256=iCNQNmsuGdL_GLnqVhGDisediFtedxw3C24rxSiQwx8,6674
 umaudemc/data/smcview.css,sha256=ExFqrMkSeaf8VxFrJXflyCsRW3FTwbv78q0Hoo2UVrM,3833
 umaudemc/data/smcview.js,sha256=_fHum1DRU1mhco-9-c6KqTLgiC5u_cCUf61jIK7wcIQ,14509
 umaudemc/data/templog.maude,sha256=TZ-66hVWoG6gp7gJpS6FsQn7dpBTLrr76bKo-UfHGcA,9161
-umaudemc-0.13.0.dist-info/LICENSE,sha256=MrEGL32oSWfnAZ0Bq4BZNcqnq3Mhp87Q4w6-deXfFnA,17992
-umaudemc-0.13.0.dist-info/METADATA,sha256=TxKYoZevbw_qjRETGj5rzpnrAmdWs2DEQcUT_zhgQdY,1693
-umaudemc-0.13.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-umaudemc-0.13.0.dist-info/entry_points.txt,sha256=8rYRlLkn4orZtAoujDSeol1t_UFBrK0bfjmLTNv9B44,52
-umaudemc-0.13.0.dist-info/top_level.txt,sha256=Yo_CF78HLGBSblk3890qLcx6XZ17zHCbGcT9iG8sfMw,9
-umaudemc-0.13.0.dist-info/RECORD,,
+umaudemc-0.14.0.dist-info/LICENSE,sha256=MrEGL32oSWfnAZ0Bq4BZNcqnq3Mhp87Q4w6-deXfFnA,17992
+umaudemc-0.14.0.dist-info/METADATA,sha256=nQh_n1_3pCq1rF3X1l0Ps5DIt9hlSqgd5tCAwrYW9sI,1687
+umaudemc-0.14.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+umaudemc-0.14.0.dist-info/entry_points.txt,sha256=8rYRlLkn4orZtAoujDSeol1t_UFBrK0bfjmLTNv9B44,52
+umaudemc-0.14.0.dist-info/top_level.txt,sha256=Yo_CF78HLGBSblk3890qLcx6XZ17zHCbGcT9iG8sfMw,9
+umaudemc-0.14.0.dist-info/RECORD,,

{umaudemc-0.13.0.dist-info → umaudemc-0.14.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

umaudemc/command/acheck.py

@@ -1,21 +0,0 @@
-#
-# 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