umaudemc 0.13.1__py3-none-any.whl → 0.15.0__py3-none-any.whl

umaudemc/__init__.py

@@ -1 +1 @@
-__version__ = '0.13.1'
+__version__ = '0.15.0'

umaudemc/__main__.py

@@ -312,6 +312,10 @@ def build_parser():
 		type=int,
 		default=1
 	)
+	parser_scheck.add_argument(
+		'--distribute',
+		help='Distribute the computation over some machines'
+	)
 	parser_scheck.add_argument(
 		'--format', '-f',
 		help='Output format for the simulation results',
@@ -326,6 +330,18 @@ def build_parser():
 
 	parser_scheck.set_defaults(mode='scheck')
 
+	#
+	# Statistical model checking distributed worker
+	#
+
+	parser_sworker = subparsers.add_parser('sworker', help='Worker for distributed statistical model checking')
+
+	parser_sworker.add_argument('--address', '-a', help='listening address', default='127.0.0.1')
+	parser_sworker.add_argument('--port', '-p', help='listening port', type=int, default=1234)
+	parser_sworker.add_argument('--keep-file', help='keep received Maude file for debugging', action='store_true')
+
+	parser_sworker.set_defaults(mode='sworker')
+
 	#
 	# Test and benchmark test suites from the command line
 	#
@@ -501,6 +517,11 @@ def main():
 		from .command.scheck import scheck
 		return scheck(args)
 
+	# Werker for distributed statistical model-checking
+	elif args.mode == 'sworker':
+		from .command.sworker import sworker
+		return sworker(args)
+
 	# Batch test subcommand
 	elif args.mode == 'test':
 		from .command.test import test

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/scheck.py

@@ -19,10 +19,10 @@ def show_results(program, nsims, qdata):
 	qdata_it = iter(qdata)
 	q = next(qdata_it, None)
 
-	for k, (line, column, params) in enumerate(program.query_locations):
+	for k, (fname, line, column, params) in enumerate(program.query_locations):
 		# Print the query name and location only if there are many
 		if program.nqueries > 1:
-			print(f'Query {k + 1} (line {line}:{column})')
+			print(f'Query {k + 1} ({fname}:{line}:{column})')
 
 		# For parametric queries, we show the result for every value
 		var = params[0] if params else None
@@ -136,7 +136,7 @@ def scheck(args):
 		return 1
 
 	with open(args.query) as quatex_file:
-		program = parse_quatex(quatex_file, filename=args.query)
+		program, seen_files = parse_quatex(quatex_file, filename=args.query, legacy=args.assign == 'pmaude')
 
 	if not program:
 		return 1
@@ -145,14 +145,7 @@ def scheck(args):
 		usermsgs.print_warning('No queries in the input file.')
 		return 0
 
-	# Get the simulator for the given assignment method
-	simulator = get_simulator(args.assign, data)
-
-	if not simulator:
-		return 1
-
 	# Check the simulation parameters
-
 	if not (0 <= args.alpha <= 1):
 		usermsgs.print_error(f'Wrong value {args.alpha} for the alpha parameter (must be between 0 and 1).')
 		return 1
@@ -170,10 +163,26 @@ def scheck(args):
 	if min_sim is None and max_sim is None:
 		return 1
 
-	# Call the statistical model checker
-	num_sims, qdata = check(program, simulator,
-	                        args.seed, args.alpha, args.delta, args.block,
-	                        min_sim, max_sim, args.jobs, args.verbose)
+	# Distributed computations follow a different path
+	if args.distribute:
+		from ..distributed import distributed_check
+
+		num_sims, qdata = distributed_check(args, data, min_sim, max_sim, program, seen_files)
+
+		if num_sims is None:
+			return 1
+
+	else:
+		# Get the simulator for the given assignment method
+		simulator = get_simulator(args.assign, data)
+
+		if not simulator:
+			return 1
+
+		# Call the statistical model checker
+		num_sims, qdata = check(program, simulator,
+		                        args.seed, args.alpha, args.delta, args.block,
+		                        min_sim, max_sim, args.jobs, args.verbose)
 
 	# Print the results on the terminal
 	(show_json if args.format == 'json' else show_results)(program, num_sims, qdata)

umaudemc/command/sworker.py

@@ -0,0 +1,185 @@
+#
+# Command for a worker of the statistical model checker
+#
+
+import json
+import multiprocessing as mp
+import os
+import socket
+import sys
+import tarfile
+import tempfile
+from array import array
+
+from ..common import maude, parse_initial_data, usermsgs
+from ..quatex import parse_quatex
+from ..simulators import get_simulator
+from ..statistical import run, QueryData, make_parameter_dicts
+
+# Python-version-dependent option for safer TAR extraction
+EXTRACT_OPTIONS = {'filter': 'data'} if sys.version_info >= (3, 12) else {}
+
+
+def read_json(sock):
+	"""Read a JSON value from a socket"""
+
+	# Read a 32 bit integer for the value length in bytes
+	if not (data := sock.recv(4)):
+		return None
+
+	length = int.from_bytes(data, 'big')
+
+	# Read the JSON to a byte string
+	data = b''
+
+	while len(data) < length:
+		data += sock.recv(length)
+
+	return json.loads(data.decode())
+
+
+class Dummy:
+	"""Dummy class to be used as a namespace"""
+
+	def __init__(self, values):
+		self.__dict__ = values
+
+
+class Worker:
+	"""Worker for simulations"""
+
+	def __init__(self):
+		self.program = None
+		self.simulator = None
+		self.block = 100
+
+	def setup(self, tmp_dir, args):
+		"""Setup the execution environment"""
+
+		# Copy parameters
+		self.block = args.block
+
+		maude.setRandomSeed(args.seed)
+
+		# Do the same as the scheck command without checks
+		args.file = os.path.join(tmp_dir, args.file)
+
+		if not (data := parse_initial_data(args)):
+			return False
+
+		with open(os.path.join(tmp_dir, args.query)) as quatex_file:
+			self.program, _ = parse_quatex(quatex_file, filename=args.query,
+			                               legacy=args.assign == 'pmaude')
+
+		if not self.program:
+			return False
+
+		# Get the simulator for the given assignment method
+		self.simulator = get_simulator(args.assign, data)
+
+		if not self.simulator:
+			return False
+
+		return True
+
+	def run(self, conn):
+		"""Run the simulation until it is finished"""
+
+		program = self.program
+		simulator = self.simulator
+		block = self.block
+
+		# Query data
+		qdata = [QueryData(k, idict)
+		         for k, qinfo in enumerate(program.query_locations)
+		         for idict in make_parameter_dicts(qinfo[3])]
+
+		sums = array('d', [0.0] * len(qdata))
+		sum_sq = array('d', [0.0] * len(qdata))
+
+		while True:
+
+			for _ in range(block):
+				# Run the simulation and compute all queries at once
+				values = run(program, qdata, simulator)
+
+				for k in range(len(qdata)):
+					sums[k] += values[k]
+					sum_sq[k] += values[k] * values[k]
+
+			conn.send(b'b' + sums.tobytes() + sum_sq.tobytes())
+
+			# Check whether to continue
+			answer = conn.recv(1)
+
+			if answer == b's':
+				print('Done')
+				return
+
+			elif answer != b'c':
+				usermsgs.print_error(f'Unknown command {answer.decode()}. Stopping.')
+				return
+
+			for k in range(len(qdata)):
+				sums[k] = 0
+				sum_sq[k] = 0
+
+
+def handle_request(message, conn, addr, keep_file):
+	"""Handle a request in a separate process"""
+
+	command = Dummy(message)
+
+	with tempfile.TemporaryDirectory(delete=not keep_file) as tmp_dir:
+		# Print the temporary working directory for debugging purposes
+		if keep_file:
+			print('Temporary directory:', tmp_dir)
+
+		# Recover the required files
+		with conn.makefile('rb', buffering=0) as fobj:
+			with tarfile.open(mode='r|*', fileobj=fobj) as tarf:
+				tarf.extractall(tmp_dir, **EXTRACT_OPTIONS)
+
+		# Setup a worker object
+		worker = Worker()
+
+		if not worker.setup(tmp_dir, command):
+			usermsgs.print_error(f'{addr}: bad request from scheck')
+			conn.send(b'e')
+			return
+
+		# Send confirmation
+		conn.send(b'o')
+
+		# Wait for start signal
+		conn.recv(1)
+
+		worker.run(conn)
+
+
+def sworker(args):
+	"""Worker for distributed statistical model checking"""
+
+	# Parse the listing address
+	try:
+		with socket.create_server((args.address, args.port), backlog=1) as sock:
+			while True:
+				print(f'👂 Listening on {args.address}:{args.port}...')
+				conn, addr = sock.accept()
+
+				usermsgs.print_info(f'Accepted connection from {":".join(map(str, addr))}.')
+
+				while True:
+					# Read the initiation message
+					if (message := read_json(conn)) is None:
+						break
+
+					# A separate process to cleanup Maude state
+					process = mp.Process(target=handle_request, args=(message, conn, addr, args.keep_file))
+					process.start()
+					process.join()
+
+	except KeyboardInterrupt:
+		print('Server closed by the user.')
+
+	return 0

umaudemc/command/test.py

@@ -14,7 +14,7 @@ import sys         # To find the Python executable path
 import threading   # To support timeouts
 import time        # To measure time
 
-from ..common import maude, usermsgs
+from ..common import maude, usermsgs, load_specification
 from ..formulae import Parser, collect_aprops
 from ..backends import supported_logics, get_backends, backend_for
 from ..terminal import terminal as tmn
@@ -62,67 +62,7 @@ class TestCase:
 def load_cases(filename):
 	"""Load test cases from YAML or JSON specifications"""
 
-	extension = os.path.splitext(filename)[1]
-
-	# The YAML package is only loaded when needed
-	# (pyaml is an optional dependency)
-	if extension in ('.yaml', '.yml'):
-		try:
-			import yaml
-			from yaml.loader import SafeLoader
-
-		except ImportError:
-			usermsgs.print_error(
-				'Cannot load cases from YAML file, since the yaml package is not installed.\n'
-				'Please convert the YAML to JSON or install it with pip install pyaml.')
-			return None
-
-		# The YAML loader is replaced so that entities have its line number
-		# associated to print more useful messages. This is not possible with
-		# the standard JSON library.
-
-		class SafeLineLoader(SafeLoader):
-			def construct_mapping(self, node, deep=False):
-				mapping = super(SafeLineLoader, self).construct_mapping(node, deep=deep)
-				# Add 1 so line numbering starts at 1
-				mapping['__line__'] = node.start_mark.line + 1
-				return mapping
-
-		try:
-			with open(filename) as caspec:
-				return yaml.load(caspec, Loader=SafeLineLoader)
-
-		except yaml.error.YAMLError as ype:
-			usermsgs.print_error(f'Error while parsing test file: {ype}.')
-
-	# TOML format
-	if extension == '.toml':
-		try:
-			import tomllib
-
-		except ImportError:
-			usermsgs.print_error(
-				'Cannot load cases from TOML file, '
-				'which is only available since Python 3.10.')
-			return None
-
-		try:
-			with open(filename) as caspec:
-				return tomllib.load(caspec)
-
-		except tomllib.TOMLDecodeError as tde:
-			usermsgs.print_error(f'Error while parsing test file: {tde}.')
-
-	# JSON format
-	else:
-		try:
-			with open(filename) as caspec:
-				return json.load(caspec)
-
-		except json.JSONDecodeError as jde:
-			usermsgs.print_error(f'Error while parsing test file: {jde}.')
-
-	return None
+	return load_specification(filename, 'cases')
 
 
 def read_suite(filename, from_file=None, skip_case=0):
@@ -280,7 +220,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
 
 
@@ -43,27 +44,43 @@ def find_maude_file_abs(filename):
 	return None
 
 
-def find_maude_file(filename):
-	"""Find a Maude file taking MAUDE_LIB into account"""
-	if os.path.isabs(filename):
-		return find_maude_file_abs(filename)
+class MaudeFileFinder:
+	"""Locate Maude files as Maude does"""
 
-	# Maude also considers the current working directory
-	# and the directory of the Maude binary
-	paths = [os.getcwd(), os.path.dirname(maude.__file__)]
+	MAUDE_STD = {'file', 'linear', 'machine-int', 'metaInterpreter', 'model-checker',
+	             'prelude', 'prng', 'process', 'smt', 'socket', 'term-order', 'time'}
 
-	maudelib = os.getenv('MAUDE_LIB')
 
-	if maudelib is not None:
-		paths += maudelib.split(os.pathsep)
+	def __init__(self):
+		# Maude also considers the current working directory
+		# and the directory of the Maude binary
+		self.paths = [os.path.dirname(maude.__file__),
+		              *os.getenv('MAUDE_LIB', '').split(os.pathsep)]
 
-	for path in paths:
-		abspath = os.path.join(path, filename)
-		fullname = find_maude_file_abs(abspath)
-		if fullname is not None:
-			return fullname
+	def _is_std(self, name):
+		"""Is this a file from the Maude distribution"""
 
-	return None
+		return name in self.MAUDE_STD or f'{name}.maude' in self.MAUDE_STD
+
+	def find(self, name, cwd):
+		# Absolute path, no ambiguity
+		if os.path.isabs(name):
+			return find_maude_file_abs(name), False
+
+		for path in (cwd, *self.paths):
+			abspath = os.path.join(path, name)
+			fullname = find_maude_file_abs(abspath)
+
+			if fullname is not None:
+				return fullname, path != cwd and self._is_std(name)
+
+		return None, None
+
+
+def find_maude_file(filename):
+	"""Find a Maude file taking MAUDE_LIB into account"""
+
+	return MaudeFileFinder().find(filename, os.getcwd())[0]
 
 
 def parse_initial_data(args):
@@ -190,3 +207,71 @@ def default_model_settings(logic, purge_fails, merge_states, strategy, tableau=F
 		merge_states = 'state' if logic.startswith('CTL') else ('edge' if logic == 'Mucalc' else 'no')
 
 	return purge_fails, merge_states
+
+
+def load_specification(filename, topic):
+	"""Load specifications from YAML or JSON files"""
+
+	extension = os.path.splitext(filename)[1]
+
+	# The YAML package is only loaded when needed
+	# (pyaml is an optional dependency)
+	if extension in ('.yaml', '.yml'):
+		try:
+			import yaml
+			from yaml.loader import SafeLoader
+
+		except ImportError:
+			usermsgs.print_error(
+				f'Cannot load {topic} from YAML file, since the yaml package is not installed.\n'
+				'Please convert the YAML to JSON or install it with pip install pyaml.')
+			return None
+
+		# The YAML loader is replaced so that entities have its line number
+		# associated to print more useful messages. This is not possible with
+		# the standard JSON library.
+
+		class SafeLineLoader(SafeLoader):
+			def construct_mapping(self, node, deep=False):
+				mapping = super(SafeLineLoader, self).construct_mapping(node, deep=deep)
+				# Add 1 so line numbering starts at 1
+				mapping['__line__'] = node.start_mark.line + 1
+				return mapping
+
+		try:
+			with open(filename) as caspec:
+				return yaml.load(caspec, Loader=SafeLineLoader)
+
+		except yaml.error.YAMLError as ype:
+			usermsgs.print_error(f'Error while parsing {topic} file: {ype}.')
+
+	# TOML format
+	if extension == '.toml':
+		try:
+			import tomllib
+
+		except ImportError:
+			usermsgs.print_error(
+				f'Cannot load {topic} from TOML file, '
+				'which is only available since Python 3.10.')
+			return None
+
+		try:
+			with open(filename, 'rb') as caspec:
+				return tomllib.load(caspec)
+
+		except tomllib.TOMLDecodeError as tde:
+			usermsgs.print_error(f'Error while parsing {topic} file: {tde}.')
+
+	# JSON format
+	else:
+		import json
+
+		try:
+			with open(filename) as caspec:
+				return json.load(caspec)
+
+		except json.JSONDecodeError as jde:
+			usermsgs.print_error(f'Error while parsing {topic} file: {jde}.')
+
+	return 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()"