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

umaudemc/__init__.py

@@ -1 +1 @@
-__version__ = '0.14.0'
+__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/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):

umaudemc/common.py

@@ -44,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):
@@ -191,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/distributed.py

@@ -0,0 +1,322 @@
+#
+# Distributed model checking
+#
+
+import io
+import json
+import os
+import random
+import re
+import selectors
+import socket
+import tarfile
+from array import array
+from contextlib import ExitStack
+
+from .common import load_specification, usermsgs, MaudeFileFinder
+from .statistical import QueryData, check_interval, get_quantile_func, make_parameter_dicts
+
+# Regular expression for Maude inclusions
+LOAD_REGEX = re.compile(rb'^\s*s?load\s+("((?:[^"\\]|\\.)+)"|\S+)')
+EOF_REGEX = re.compile(rb'^\s*eof($|\s)')
+TOP_COMMENT_REGEX = re.compile(rb'(?:\*{3}|-{3})\s*(.)')
+NESTED_COMMENT_REGEX = re.compile(rb'[\(\)]')
+
+
+def strip_comments(fobj):
+	"""Strip Maude comments from a file"""
+
+	comment_depth = 0  # depth of nested multiline comments
+	chunks = []
+
+	for line in fobj:
+		start = 0
+
+		while True:
+			# Inside a multiline comment
+			if comment_depth > 0:
+				# Find a the start or end of a multiline comment
+				if m := NESTED_COMMENT_REGEX.search(line, start):
+					if m.group(0) == b')':  # end
+						comment_depth -= 1
+
+					else:  # start
+						comment_depth += 1
+
+					start = m.end()
+
+				# The whole line is inside a multiline comment
+				else:
+					break
+
+			# Not inside a comment
+			else:
+				if m := TOP_COMMENT_REGEX.search(line, start):
+					chunks.append(line[start:m.start()] + b'\n')
+
+					# Start of multiline comment
+					if m.group(1) == b'(':
+						start = m.end()
+						comment_depth += 1
+
+					# Single line comment
+					else:
+						break
+
+				# No comment at all
+				else:
+					chunks.append(line[start:])
+					break
+
+		if chunks:
+			yield b' '.join(chunks)
+			chunks.clear()
+
+
+def flatten_maude_file(filename, fobj):
+	"""Scan sources for its dependencies"""
+
+	# Maude file finder
+	mfinder = MaudeFileFinder()
+
+	# Files are explored depth-first
+	stack = [(lambda v: (filename, v, strip_comments(v)))(open(filename, 'rb'))]
+	# Files already included to avoid double inclusion (loads are interpreted as sloads)
+	seen = {os.path.realpath(filename)}
+
+	while stack:
+		fname, file, lines = stack[-1]
+
+		while line := next(lines, None):
+			# Load commands are only allowed at the beginning of a line
+			if m := LOAD_REGEX.match(line):
+				# File name (with quotes, maybe)
+				next_fname = m.group(1).decode()
+
+				if next_fname[0] == '"':
+					next_fname = next_fname[1:-1].replace(r'\"', '"')
+
+				# Inclusions are tricky
+				next_path, is_std = mfinder.find(next_fname, os.path.dirname(fname))
+
+				# For standard files, we preserve the inclusion
+				if is_std:
+					fobj.write(line)
+
+				# Otherwise, we copy the file unless already done
+				elif next_path not in seen:
+					next_file = open(next_path, 'rb')
+					stack.append((next_path, next_file, strip_comments(next_file)))
+					seen.add(next_path)
+					break
+
+			elif EOF_REGEX.match(line):
+				line = None
+				break
+			else:
+				fobj.write(line)
+
+		# Whether the file is exhausted
+		if line is None:
+			fobj.write(b'\n')  # just in case there is no line break at end of file
+			stack.pop()
+			file.close()
+
+
+def process_dspec(dspec, fname):
+	"""Normalize a distributed SMC specification"""
+
+	# Normalize workers to a dictionary
+	workers = dspec.get('workers')
+
+	if not isinstance(workers, list):
+		usermsgs.print_error_file('the distribution specification does not contain a list-valued \'workers\' key.', fname)
+		return False
+
+	for k, worker in enumerate(workers):
+		# Strings address:port are allowed
+		if isinstance(worker, str):
+			try:
+				address, port = worker.split(':')
+				worker = {'address': address, 'port': int(port)}
+
+			except ValueError:
+				usermsgs.print_error_file(f'bad address specification {worker} for worker {k + 1} '
+				                          '(it should be <address>:<port>).', fname)
+				return False
+
+			workers[k] = worker
+
+		# Otherwise, it must be a dictionary
+		elif not isinstance(worker, dict):
+			usermsgs.print_error_file(f'the specification for worker {k + 1} is not a dictionary.', fname)
+			return False
+
+		# With address and port keys
+		else:
+			for key, ktype in (('address', str), ('port', int)):
+				if key not in worker:
+					usermsgs.print_error_file(f'missing key \'{key}\' for worker {k + 1}.', fname)
+					return False
+
+				if not isinstance(worker[key], ktype):
+					usermsgs.print_error_file(f'wrong type for key \'{key}\' in worker {k + 1}, {ktype.__name__} expected.', fname)
+					return False
+
+		# Name just for reference in errors and messages
+		if 'name' not in worker:
+			worker['name'] = f'{worker["address"]}:{worker["port"]}'
+
+	return True
+
+
+def setup_workers(args, initial_data, dspec, seen_files, stack):
+	"""Setup workers and send problem data"""
+
+	workers = dspec['workers']
+
+	# Generate a random seed for each worker
+	seeds = [random.getrandbits(20) for _ in range(len(workers))]
+
+	# Data to be passed to the external machine
+	COPY = ('initial', 'strategy', 'module', 'metamodule', 'opaque', 'full_matchrew',
+	        'purge_fails', 'merge_states', 'assign', 'block', 'query', 'assign', 'advise', 'verbose')
+
+	data = {key: args.__dict__[key] for key in COPY} | {'file': 'source.maude'}
+
+	# Make a flattened version of the Maude file
+	flat_source = io.BytesIO()
+	flatten_maude_file(initial_data.filename, flat_source)
+
+	flat_info = tarfile.TarInfo('source.maude')
+	flat_info.size = flat_source.getbuffer().nbytes
+
+	# Save the sockets for each worker
+	sockets = []
+
+	for worker, seed in zip(workers, seeds):
+		address, port = worker['address'], worker['port']
+
+		try:
+			sock = socket.create_connection((address, int(port)))
+
+		except ConnectionRefusedError:
+			usermsgs.print_error(f'Connection refused by worker \'{worker["name"]}\'.')
+			return None
+
+		stack.enter_context(sock)
+		sockets.append(sock)
+
+		# Send the input data
+		input_data = data | {'seed': seed}
+
+		if block_size := worker.get('block'):
+			input_data['block'] = block_size  # if specified
+
+		input_data = json.dumps(input_data).encode()
+		sock.sendall(len(input_data).to_bytes(4) + input_data)
+
+		# Send the relevant files
+		with sock.makefile('wb', buffering=0) as fobj:
+			with tarfile.open(mode='w|gz', fileobj=fobj) as tarf:
+				flat_source.seek(0)
+				tarf.addfile(flat_info, flat_source)
+
+				for file in seen_files:
+					relpath = os.path.relpath(file)
+
+					if relpath.startswith('..'):
+						usermsgs.print_error('QuaTEx file outside the working tree, it will not be included and the execution will fail.')
+					else:
+						tarf.add(relpath)
+
+			fobj.flush()
+
+		# Receive confirmation from the remote
+		answer = sock.recv(1)
+
+		if answer != b'o':
+			usermsgs.print_error(f'Configuration error in {worker["name"]} worker.')
+			return None
+
+	return sockets
+
+
+def distributed_check(args, initial_data, min_sim, max_sim, program, seen_files):
+	"""Distributed statistical model checking"""
+
+	# Load the distribution specification
+	if (dspec := load_specification(args.distribute, 'distribution specification')) is None \
+	   or not process_dspec(dspec, args.distribute):
+		return None, None
+
+	# Gather all sockets in a context to close them when we finish
+	with ExitStack() as stack:
+
+		# Socket to connect with the workers
+		if not (sockets := setup_workers(args, initial_data, dspec, seen_files, stack)):
+			return None, None
+
+		print('All workers are ready. Starting...')
+
+		# Use a selector to wait for updates from any worker
+		selector = selectors.DefaultSelector()
+
+		for sock, data in zip(sockets, dspec['workers']):
+			selector.register(sock, selectors.EVENT_READ, data=data)
+			sock.send(b'c')
+
+		buffer = array('d')
+
+		# Query data
+		qdata = [QueryData(k, idict)
+		         for k, qinfo in enumerate(program.query_locations)
+		         for idict in make_parameter_dicts(qinfo[3])]
+		nqueries = len(qdata)
+		num_sims = 0
+
+		quantile = get_quantile_func()
+
+		while sockets:
+			events = selector.select()
+			finished = []
+
+			for key, _ in events:
+				sock = key.fileobj
+
+				answer = sock.recv(1)
+
+				if answer == b'b':
+					data = sock.recv(16 * nqueries)
+					buffer.frombytes(data)
+
+					for k in range(nqueries):
+						qdata[k].sum += buffer[k]
+						qdata[k].sum_sq += buffer[nqueries + k]
+
+					num_sims += key.data['block']
+
+					del buffer[:]
+					finished.append(key.fileobj)
+
+				else:
+					usermsgs.print_error(f'Server {key.data["name"]} disconnected or misbehaving')
+					selector.unregister(key.fileobj)
+					sockets.remove(key.fileobj)
+
+			# Check whether the simulation has converged
+			converged = check_interval(qdata, num_sims, args.alpha, args.delta, quantile, args.verbose)
+
+			if converged or max_sim and num_sims >= max_sim:
+				break
+
+			for sock in finished:
+				sock.send(b'c')
+
+			finished.clear()
+
+		# Send stop signal to all workers
+		for sock in sockets:
+			sock.send(b's')
+
+	return num_sims, qdata

umaudemc/kleene.py

@@ -13,6 +13,10 @@ class KleeneExecutionState(GraphExecutionState):
 		super().__init__(term, pc, stack, conditional, graph_node,
 		                 (extra, set() if iterations is None else iterations))
 
+		# The second position of the extra attribute is a set of iteration tags of the
+		# form ((pc, ctx), enters) where (pc, ctx) identifies the iteration and enters
+		# indicates whether it enters or leaves
+
 	def copy(self, term=None, pc=None, stack=None, conditional=False, graph_node=None, extra=None):
 		"""Clone state with possibly some changes"""
 
@@ -44,6 +48,7 @@ class KleeneRunner(GraphRunner):
 
 	def kleene(self, args, stack):
 		"""Keep track of iterations"""
+		# Identify each dynamic context with a number
 		context_id = self.iter_contexts.setdefault(self.current_state.stack, len(self.iter_contexts))
 		self.current_state.add_kleene(((args[0], context_id), args[1]))
 		super().kleene(args, stack)
@@ -119,7 +124,7 @@ class StrategyKleeneGraph:
 	def expand(self):
 		"""Expand the underlying graph"""
 
-		for k, state in enumerate(self.state_list):
+		for state in self.state_list:
 			for child in state.children:
 				if child not in self.state_map:
 					self.state_map[child] = len(self.state_list)

umaudemc/quatex.py

@@ -3,6 +3,7 @@
 #
 
 import ast
+import os
 
 from . import usermsgs
 
@@ -21,7 +22,7 @@ class QuaTExProgram:
 		# Number of queries
 		self.nqueries = len(slots) - ndefs
 
-		# Query information (line, column, and parameters)
+		# Query information (file name, line, column, and parameters)
 		self.query_locations = qinfo
 
 
@@ -33,9 +34,10 @@ class QuaTExLexer:
 	LT_STRING = 2
 	LT_OTHER = 3
 
-	def __init__(self, source, buffer_size=512):
+	def __init__(self, source, filename, buffer_size=512):
 		# Input stream (file-like object)
 		self.source = source
+		self.filename = filename
 		# We read in chunks of buffer_size
 		self.buffer_size = buffer_size
 		self.buffer = self.source.read(self.buffer_size)
@@ -221,10 +223,15 @@ class QuaTExParser:
 	UNARY_OPS = ('!', )
 	UNARY_AST = (ast.Not, )
 
-	def __init__(self, source, filename='<stdin>'):
-		self.lexer = QuaTExLexer(source)
+	def __init__(self, source, filename='<stdin>', legacy=False):
 		# Filename is only used for diagnostics
-		self.filename = filename
+		self.lexer = QuaTExLexer(source, filename)
+		# PMaude legacy syntax
+		self.legacy = legacy
+
+		# File inclusion support
+		self.pending_lexers = []
+		self.seen_files = set() if filename.startswith('<') else {os.path.realpath(filename)}
 
 		# Parameters of the current function
 		self.fvars = []
@@ -246,10 +253,10 @@ class QuaTExParser:
 		self.queries = []
 		self.defs = []
 
-	def _eprint(self, msg, line=None, column=None):
+	def _eprint(self, msg, line=None, column=None, fname=None):
 		"""Print an error message with line information"""
 
-		usermsgs.print_error_loc(self.filename,
+		usermsgs.print_error_loc(fname or self.lexer.filename,
 		                         line or self.lexer.sline,
 		                         column or self.lexer.scolumn,
 		                         msg)
@@ -275,6 +282,19 @@ class QuaTExParser:
 
 		return self.stack and self.stack[-1] == state
 
+	def _next_token(self):
+		"""Get the next token without potential file exhaustion"""
+
+		token = self.lexer.get_token()
+
+		while self.lexer.exhausted and self.pending_lexers:
+			self.lexer, open_file = self.pending_lexers.pop()
+			open_file.close()
+
+			token = self.lexer.get_token()
+
+		return token
+
 	def _do_binop(self, op_index, left, right):
 		"""Build a binary operator in the AST"""
 
@@ -482,7 +502,7 @@ class QuaTExParser:
 				line, column = self.lexer.sline, self.lexer.scolumn
 				next_token = self.lexer.get_token()
 
-				# A call to s.reval
+				# A call to s.rval
 				if token == 's' and next_token == '.':
 					if not self._expect('rval', '('):
 						return None
@@ -490,7 +510,8 @@ class QuaTExParser:
 					token = self.lexer.get_token()
 					ltype = self.lexer.ltype
 
-					if ltype not in (self.lexer.LT_NAME, self.lexer.LT_STRING, self.lexer.LT_NUMBER):
+					if ltype not in (self.lexer.LT_NAME, self.lexer.LT_STRING) and \
+					   not (self.legacy and ltype == self.lexer.LT_NUMBER):
 						self._eprint(f's.rval only admits string literals and variables, but "{token}" is found.')
 						return None
 
@@ -596,17 +617,44 @@ class QuaTExParser:
 	def _parse_toplevel(self):
 		"""Parse the top level of a QuaTeX file"""
 
-		token = self.lexer.get_token()
-
-		while not self.lexer.exhausted:
+		while token := self._next_token():
 
 			# Any top level statement starts with eval or other identifier
 			if self.lexer.ltype != self.lexer.LT_NAME:
 				self._eprint(f'unexpected token "{token}" at the top level.')
 				return False
 
+			# Import statement -- import "filename" ;
+			if token == 'import':
+				line, column = self.lexer.sline, self.lexer.scolumn
+
+				# Get the filename, it must be a string
+				path = self.lexer.get_token()
+
+				if self.lexer.ltype != self.lexer.LT_STRING:
+					self._eprint(f'unexpected token "{path}" where a string is required.')
+					return False
+
+				if not self._expect(';'):
+					return False
+
+				# Check whether the file exists
+				new_path = os.path.join(os.path.dirname(self.lexer.filename), path[1:-1])
+
+				if not os.path.exists(new_path):
+					self._eprint(f'cannot import {path}, file not found', line, column)
+					return False
+
+				# Jump to that file if it has not been processed yet
+				if (canonical_path := os.path.realpath(new_path)) not in self.seen_files:
+					self.seen_files.add(canonical_path)
+
+					new_file = open(new_path)
+					self.pending_lexers.append((self.lexer, new_file))
+					self.lexer = QuaTExLexer(new_file, new_path)
+
 			# Query -- eval E [ <expr> ] ;
-			if token == 'eval':
+			elif token == 'eval':
 				# The query location is kept for future reference
 				line, column = self.lexer.sline, self.lexer.scolumn
 
@@ -638,10 +686,10 @@ class QuaTExParser:
 
 				# Ignore parameterized expressions with empty range
 				if parameter and parameter[1] > parameter[3]:
-					usermsgs.print_warning_loc(self.filename, line, column,
+					usermsgs.print_warning_loc(self.lexer.filename, line, column,
 					                           'ignoring parametric query with empty range.')
 				else:
-					self.queries.append((line, column, expr, parameter))
+					self.queries.append((self.lexer.filename, line, column, expr, parameter))
 
 			# Function definition -- <name> ( <args> ) = <expr> ;
 			else:
@@ -684,8 +732,6 @@ class QuaTExParser:
 				self.defs.append((fname, line, column, tuple(self.fvars), expr))
 				self.fvars.clear()
 
-			token = self.lexer.get_token()
-
 		return self.ok
 
 	def _check_tail(self, expr):
@@ -732,7 +778,7 @@ class QuaTExParser:
 			else:
 				arities[name] = len(args)
 
-		# Check whether all called are well-defined
+		# Check whether all calls are well-defined
 		for name, line, column, arity in self.calls:
 			def_arity = arities.get(name)
 
@@ -751,7 +797,7 @@ class QuaTExParser:
 			if not self._check_tail(expr):
 				ok = False
 
-		for line, column, expr, _ in self.queries:
+		for _, _, _, expr, _ in self.queries:
 			if not self._check_tail(expr):
 				ok = False
 
@@ -782,26 +828,28 @@ class QuaTExParser:
 				             line=line, column=column)
 				ok = False
 
-		for k, (line, column, expr, _) in enumerate(self.queries):
+		for k, (fname, line, column, expr, _) in enumerate(self.queries):
 			try:
 				expr = ast.Expression(expr)
 				ast.fix_missing_locations(expr)
-				slots[used_defs + k] = compile(expr, filename=f'query{line}:{column}', mode='eval')
+				slots[used_defs + k] = compile(expr, filename=f'query{fname}:{line}:{column}', mode='eval')
 
 			except TypeError:
 				self._eprint('this query cannot cannot be compiled.',
-				             line=line, column=column)
+				             line=line, column=column, fname=fname)
 				ok = False
 
 		if not ok:
 			return None
 
 		return QuaTExProgram(slots, varnames, len(self.fslots),
-		                     tuple((line, column, params) for line, column, _, params in self.queries))
+		                     tuple((fname, line, column, params) for fname, line, column, _, params in self.queries))
 
 
-def parse_quatex(input_file, filename='<string>'):
+def parse_quatex(input_file, filename='<string>', legacy=False):
 	"""Parse a QuaTEx formula"""
 
 	# Load, parse, and compile the QuaTEx file
-	return QuaTExParser(input_file, filename=filename).parse()
+	parser = QuaTExParser(input_file, filename=filename, legacy=legacy)
+
+	return parser.parse(), parser.seen_files

umaudemc/simulators.py

@@ -218,7 +218,7 @@ class StrategyDTMCSimulator(BaseSimulator):
 		p = sc.compile(ml.upStrategy(strategy))
 
 		try:
-			self.graph = MarkovRunner(p, initial).run()
+			self.graph, _ = MarkovRunner(p, initial).run()
 			self.node = self.graph
 			self.time = 0.0
 

umaudemc/statistical.py

@@ -133,9 +133,9 @@ def check_interval(qdata, num_sims, alpha, delta, quantile, verbose):
 	# Whether the size of the confidence interval for all queries have converged
 	converged = True
 
-	for k, query in enumerate(qdata):
+	for query in qdata:
 		query.mu = query.sum / num_sims
-		query.s = math.sqrt((query.sum_sq - query.sum * query.mu) / (num_sims - 1))
+		query.s = math.sqrt(max(query.sum_sq - query.sum * query.mu, 0.0) / (num_sims - 1))
 		query.h = query.s * tinv
 
 		if query.h > delta:
@@ -285,7 +285,7 @@ def qdata_to_dict(num_sims, qdata, program):
 	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):
 		# For parametric queries, we return an array of values
 		if params:
 			mean, std, radius = [], [], []
@@ -303,7 +303,7 @@ def qdata_to_dict(num_sims, qdata, program):
 			mean, std, radius = q.mu, q.s, q.h
 			param_info = {}
 
-		queries.append(dict(mean=mean, std=std, radius=radius, line=line, column=column, **param_info))
+		queries.append(dict(mean=mean, std=std, radius=radius, file=fname, line=line, column=column, **param_info))
 
 	return dict(nsims=num_sims, queries=queries)
 
@@ -326,7 +326,7 @@ def check(program, simulator, seed, alpha, delta, block, min_sim, max_sim, jobs,
 	# and the sum of their squares
 	qdata = [QueryData(k, idict)
 	         for k, qinfo in enumerate(program.query_locations)
-	         for idict in make_parameter_dicts(qinfo[2])]
+	         for idict in make_parameter_dicts(qinfo[3])]
 
 	# Run the simulations
 	if jobs == 1 and num_sims != 1:

umaudemc/usermsgs.py

@@ -23,6 +23,12 @@ def print_error_loc(unit, line, column, msg):
 	print(f'{tmn.bold}{unit}:{line}:{column}: {tmn.red}error:{tmn.reset} {msg}')
 
 
+def print_error_file(msg, unit):
+	"""Print an error with a location"""
+
+	print(f'{tmn.bold}{unit}: {tmn.red}error:{tmn.reset} {msg}')
+
+
 def print_warning_loc(unit, line, column, msg):
 	"""Print a warning with a location"""
 

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

@@ -1,16 +1,15 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: umaudemc
-Version: 0.14.0
+Version: 0.15.0
 Summary: Unified Maude model-checking utility
 Author-email: ningit <ningit@users.noreply.github.com>
-License: GPLv3
+License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/fadoss/umaudemc
 Project-URL: Bug Tracker, https://github.com/fadoss/umaudemc/issues
 Project-URL: Documentation, https://github.com/fadoss/umaudemc
 Project-URL: Source Code, https://github.com/fadoss/umaudemc
 Classifier: Programming Language :: Python :: 3
 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.9
@@ -25,6 +24,7 @@ Provides-Extra: plot
 Requires-Dist: matplotlib; extra == "plot"
 Provides-Extra: smc
 Requires-Dist: scipy; extra == "smc"
+Dynamic: license-file
 
 # Unified Maude model-checking tool
 

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

@@ -1,25 +1,26 @@
-umaudemc/__init__.py,sha256=4pkGIcN2HdoT4OEADiR3LUoE-VfT0mtYYKhwVWEwVMY,23
-umaudemc/__main__.py,sha256=PBIa2mStJwNIK5YnwoCefEB_a59VLkHE_Zp_1hnMyg4,14060
+umaudemc/__init__.py,sha256=iCWCR3zceWVR3HY2_dnmoKBKY7eAZrsQ5pfmt6srIVw,23
+umaudemc/__main__.py,sha256=x7HLEryX--lIKW1JYjF66XLZQ9lUnAQmd2ADGRipEfo,14823
 umaudemc/api.py,sha256=I-o5foy8NUlO4JT4pX9L7kkuHQG_8_GMkWlOKt708E8,19733
 umaudemc/backends.py,sha256=mzJkALYwcKPInT0lBiRsCxJSewKvx5j_akQsqWN1Ezo,4590
-umaudemc/common.py,sha256=Z1RQNwNpwHApsckHM4Zj5A0ClTuVKKKC1Lkgf9yYmqI,4926
+umaudemc/common.py,sha256=UcIf7hTpP2qjcT9u_9-UcYR0nNeosx1xRZW7wsuT2bE,7305
 umaudemc/counterprint.py,sha256=vVqM_UjGRk_xeftFxBGI5m6cQXV7mf8KvbQ_fvAvSQk,9226
+umaudemc/distributed.py,sha256=6iR02PYQBZOWZ3bIm7AP-sCSFdTazXHb25FqldUxIg8,8653
 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/kleene.py,sha256=sW5SGdXpbLrjGtihPn8qgnhSH5WgltFaLVRx6GLwQU4,4697
 umaudemc/mproc.py,sha256=9X5pTb3Z3XHcdOo8ynH7I5RZQpjzm9xr4IBbEtaglUE,11766
 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/quatex.py,sha256=SQAbVz1csGXGqcfzFcjP89BdIpN8K2aiwP_PMLGPr1o,23239
 umaudemc/resources.py,sha256=qKqvgLYTJVtsQHQMXFObyCLTo6-fssQeu_mG7tvVyD0,932
-umaudemc/simulators.py,sha256=84W30MWWe4QRxK24RGA0zuwXjPya4wH18PrhPKdOpyU,13229
-umaudemc/statistical.py,sha256=-UzP3g4Sy5L_dq2UEimobwu1qR70uEQnqKigsPEvyzU,9074
+umaudemc/simulators.py,sha256=Lk50Ql7hWUasWkQSWxboeR5LYfJtpwrANjUDuxYjuZ4,13232
+umaudemc/statistical.py,sha256=buthWv4ovvxsvDs0eWgJw7lX2_9BsnLsW_PxW17RHCI,9087
 umaudemc/terminal.py,sha256=B4GWLyW4Sdymgoavj418y4TI4MnWqNu3JS4BBoSYeTc,1037
-umaudemc/usermsgs.py,sha256=d3RfyBGEBmcV_c2MeXWCtZIiiM2vFnaHsN3MHwMnyAs,583
+umaudemc/usermsgs.py,sha256=h4VPxljyKidEI8vpPcToKJA6mcLu9PtMkIh6vH3rDuA,719
 umaudemc/webui.py,sha256=XlDV87tOOdcclHp2_oerrvHwRmCZdqAR4PppqeZm47A,11072
 umaudemc/wrappers.py,sha256=uz9JV1zBVqzkuoByUd569fEcSxT_00aCJw-jcDtrFpE,9399
 umaudemc/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -39,8 +40,9 @@ umaudemc/command/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 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=kPmV1-hIJMMxZLErqYYP50z95uME_3sLLUMXQuUy9fs,38733
+umaudemc/command/scheck.py,sha256=jiVNsLfbNDUleWl9HuNW7GTQdszd5cefZJn0_Epm9UU,4967
+umaudemc/command/sworker.py,sha256=hZv7hpZg3Z-BnTtYqNwG7y2Njyr3NMV7-EIANrj8POM,4344
+umaudemc/command/test.py,sha256=Ru21JXNF61F5N5jayjwxp8okIjOAvuZuAlV_5ltQ-GU,37088
 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
@@ -50,9 +52,9 @@ umaudemc/data/smcgraph.js,sha256=iCNQNmsuGdL_GLnqVhGDisediFtedxw3C24rxSiQwx8,667
 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.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.15.0.dist-info/licenses/LICENSE,sha256=MrEGL32oSWfnAZ0Bq4BZNcqnq3Mhp87Q4w6-deXfFnA,17992
+umaudemc-0.15.0.dist-info/METADATA,sha256=MQLEOo16TB5BJRq90duHk0UTEMVF8i8MeENz7jt1OdE,1654
+umaudemc-0.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+umaudemc-0.15.0.dist-info/entry_points.txt,sha256=8rYRlLkn4orZtAoujDSeol1t_UFBrK0bfjmLTNv9B44,52
+umaudemc-0.15.0.dist-info/top_level.txt,sha256=Yo_CF78HLGBSblk3890qLcx6XZ17zHCbGcT9iG8sfMw,9
+umaudemc-0.15.0.dist-info/RECORD,,

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

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