fm-weck 1.4.5__py3-none-any.whl → 1.4.7__py3-none-any.whl

fm_weck/engine.py

@@ -5,26 +5,35 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import io
 import logging
 import shutil
 import signal
 import subprocess
+import sys
 from abc import ABC, abstractmethod
 from functools import cached_property, singledispatchmethod
 from pathlib import Path
 from tempfile import mkdtemp
-from typing import List, Optional, Union
+from typing import TYPE_CHECKING, Callable, Iterable, List, Optional, Union
+
+from fm_weck.run_result import RunResult
 
 try:
-    from fm_tools.fmdata import FmData, FmImageConfig
+    from fm_tools.fmtoolversion import (
+        FmImageConfig,  # type: ignore
+        FmToolVersion,  # type: ignore
+    )
 except ImportError:
-    # Mock the FmData and FmImageConfig class for type checking
-    class FmData:
-        def get_images(self):
-            pass
+    # Mock the FmToolVersion and FmImageConfig class for type checking
+    if not TYPE_CHECKING:
 
-    class FmImageConfig:
-        pass
+        class FmImageConfig:
+            with_fallback: Callable[[str], "FmImageConfig"]  # type: ignore
+
+        class FmToolVersion:
+            def get_images(self) -> "FmImageConfig":  # type: ignore
+                pass
 
 
 from fm_weck.config import Config, parse_fm_data
@@ -33,7 +42,6 @@ from fm_weck.image_mgr import ImageMgr
 
 logger = logging.getLogger(__name__)
 
-
 CWD_MOUNT_LOCATION = "/home/cwd"
 CACHE_MOUNT_LOCATION = "/home/fm-weck_cache"
 OUTPUT_MOUNT_LOCATION = "/home/output"
@@ -43,6 +51,8 @@ RESERVED_LOCATIONS = frozenset([CACHE_MOUNT_LOCATION, CWD_MOUNT_LOCATION, OUTPUT
 
 class Engine(ABC):
     interactive: bool = False
+    handle_io: bool = True
+    print_output_to_stdout: bool = True
     add_benchexec_capabilities: bool = False
     add_mounting_capabilities: bool = True
     image: Optional[str] = None
@@ -111,6 +121,8 @@ class Engine(ABC):
 
     def setup_command(self):
         return [
+            "--security-opt",
+            "label=disable",
             "--entrypoint",
             '[""]',
             "-v",
@@ -137,9 +149,20 @@ class Engine(ABC):
             if file.is_file():
                 shutil.copy(file, self.output_dir / file.name)
             elif file.is_dir():
-                shutil.copytree(file, self.output_dir, dirs_exist_ok=True)
-
-    def assemble_command(self, command: tuple[str, ...]) -> list[str]:
+                try:
+                    # This may fail if there are some permission errors,
+                    # but we don't want to stop the whole process in case this happens.
+                    # One such example is UAutomizer's output which contains
+                    # some config files produced by Java.
+                    shutil.copytree(
+                        file,
+                        self.output_dir,
+                        dirs_exist_ok=True,
+                    )
+                except shutil.Error as e:
+                    logger.warning(f"Error while copying the output {file} directory: {e}")
+
+    def assemble_command(self, command: Iterable[str]) -> list[str]:
         base = self.base_command()
         if self.add_benchexec_capabilities:
             base += self.benchexec_capabilities()
@@ -162,7 +185,7 @@ class Engine(ABC):
         _command = self._prep_command(command)
         return base + [self.image, *_command]
 
-    def _prep_command(self, command: tuple[str, ...]) -> tuple[str, ...]:
+    def _prep_command(self, command: Iterable[str]) -> tuple[str | Path, ...]:
         """We want to map absolute paths of the current working directory to the
         working directory of the container."""
 
@@ -200,7 +223,7 @@ class Engine(ABC):
     def extract_image(fm: Union[str, Path], version: str, config: dict) -> str:
         image = config.get("defaults", {}).get("image", None)
 
-        return parse_fm_data(fm, version).get_images().with_fallback(image)
+        return parse_fm_data(fm, version).get_images().with_fallback(image)  # type: ignore
 
     @staticmethod
     def _base_engine_class(config: Config):
@@ -223,7 +246,7 @@ class Engine(ABC):
     @from_config.register
     @staticmethod
     def _(fm: Path, version: str, config: Config):
-        image = Engine.extract_image(fm, version, config)
+        image = Engine.extract_image(fm, version, config)  # type: ignore
         Base = Engine._base_engine_class(config)
         engine = Base(image)
         return Engine._prepare_engine(engine, config)
@@ -231,14 +254,14 @@ class Engine(ABC):
     @from_config.register
     @staticmethod
     def _(fm: str, version: str, config: Config):
-        image = Engine.extract_image(fm, version, config)
+        image = Engine.extract_image(fm, version, config)  # type: ignore
         Base = Engine._base_engine_class(config)
         engine = Base(image)
         return Engine._prepare_engine(engine, config)
 
     @from_config.register
     @staticmethod
-    def _(fm: FmData, config: Config):
+    def _(fm: FmToolVersion, config: Config):
         image = fm.get_images().with_fallback(config.from_defaults_or_none("image"))
         Base = Engine._base_engine_class(config)
         engine = Base(image)
@@ -258,10 +281,13 @@ class Engine(ABC):
         return engine
 
     @abstractmethod
-    def image_from(self, containerfile: Path) -> "BuildCommand": ...
+    def image_from(self, containerfile: Path) -> "BuildCommand":
+        pass
 
     class BuildCommand(ABC):
         build_args: List[str] = []
+        containerfile: Path
+        _engine: str
 
         @abstractmethod
         def __init__(self, containerfile: Path, **kwargs):
@@ -271,7 +297,7 @@ class Engine(ABC):
             self.build_args += ["--build-arg", f"BASE_IMAGE={image}"]
             return self
 
-        def packages(self, packages: list[str]):
+        def packages(self, packages: Iterable[str]):
             self.build_args += ["--build-arg", f"REQUIRED_PACKAGES={' '.join(packages)}"]
             return self
 
@@ -289,15 +315,43 @@ class Engine(ABC):
 
             logging.debug("Running command: %s", cmd)
 
-            ret = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            ret = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
             tag = ret.stdout.decode().splitlines()[-1].strip()
             logger.info("Built image %s", tag)
             logger.debug("Output of build image was:\n%s", ret.stdout.decode())
+            logger.debug("Error of build image was:\n%s", ret.stderr.decode())
+            if ret.returncode != 0:
+                raise subprocess.CalledProcessError(
+                    ret.returncode, cmd, output=ret.stdout.decode(), stderr=ret.stderr.decode()
+                )
 
             return tag
 
-    def _run_process(self, command: tuple[str, ...] | list[str]):
+    def _run_process_without_attaching_io(
+        self, command: tuple[str, ...] | list[str], timeout_sec: Optional[float] = None
+    ) -> RunResult:
+        def terminate_process_group(signal_received, frame):
+            if process:
+                logging.info("Received signal %s. Terminating container process.", signal_received)
+                process.send_signal(signal.SIGTERM)
+
+        # Register signal handler
+        signal.signal(signal.SIGINT, terminate_process_group)
+        signal.signal(signal.SIGTERM, terminate_process_group)
+
+        logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))
+        process = subprocess.Popen(command)
+
+        try:
+            process.wait(timeout=timeout_sec)
+        except subprocess.TimeoutExpired:
+            process.terminate()
+            process.wait()
+
+        return RunResult(command, process.returncode, "")
+
+    def _run_process(self, command: tuple[str, ...] | list[str], timeout_sec: Optional[float] = None) -> RunResult:
         process = None  # To make sure process is defined if a signal is caught early
 
         def terminate_process_group(signal_received, frame):
@@ -310,31 +364,55 @@ class Engine(ABC):
         signal.signal(signal.SIGTERM, terminate_process_group)
 
         logger.debug("\n\nRunning command:\n%s\n\n", " ".join(map(str, command)))
+
+        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        full_stdout = io.StringIO()
+
+        def run_and_poll(writer: Callable[[str], None]):
+            while process.poll() is None:
+                if process.stdout is None:
+                    continue
+                line = process.stdout.readline().decode("utf-8")
+                writer(line)
+                if self.print_output_to_stdout:
+                    sys.stdout.write(line)
+
         if self.log_file is None:
-            process = subprocess.Popen(command)
+            run_and_poll(full_stdout.write)  # type: ignore
         else:
-            self.log_file.parent.mkdir(parents=True, exist_ok=True)
-            with self.log_file.open("wb") as f:
-                process = subprocess.Popen(command, stdout=f, stderr=f)
+            with self.log_file.open("w") as log:
+                run_and_poll(log.write)  # type: ignore
 
         assert process is not None, "Process should be defined at this point."
-        process.wait()
-        return process.returncode
+        try:
+            process.wait(timeout=timeout_sec)
+        except subprocess.TimeoutExpired:
+            process.terminate()
+            process.wait()
 
-    def run(self, *command: str) -> int:
+        if self.log_file is not None:
+            with self.log_file.open("r") as log:
+                return RunResult(command, process.returncode, log.read())
+
+        return RunResult(command, process.returncode, full_stdout.read())
+
+    def run(self, *command: str, timeout_sec: Optional[float] = None) -> RunResult:
         if self.image is None:
             raise NoImageError("No image set for engine.")
 
-        command = self.assemble_command(command)
+        command = self.assemble_command(command)  # type: ignore
         logger.debug("Running: %s", command)
         if self.dry_run:
             print("Command to be executed:")
             print(" ".join(map(str, command)))
-            return 0
+            return RunResult(command, 0, "Dry run: no command executed.")
+
+        if self.interactive or not self.handle_io:
+            return self._run_process_without_attaching_io(command, timeout_sec=timeout_sec)
 
-        return_code = self._run_process(command)
+        result = self._run_process(command, timeout_sec=timeout_sec)
         self._move_output()
-        return return_code
+        return result
 
 
 class Podman(Engine):

fm_weck/exceptions.py

@@ -5,5 +5,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+
 class NoImageError(Exception):
     pass

fm_weck/image_mgr.py

@@ -10,12 +10,13 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 try:
-    from fm_tools.fmdata import FmImageConfig
+    from fm_tools.fmtoolversion import FmImageConfig
 except ImportError:
+    if not TYPE_CHECKING:
 
-    class FmImageConfig:
-        def __init__(self, full_images, base_images, required_packages):
-            raise ImportError("fm_tools is not imported.")
+        class FmImageConfig:
+            def __init__(self, full_images, base_images, required_packages):
+                raise ImportError("fm_tools is not imported.")
 
 
 from fm_weck.exceptions import NoImageError

fm_weck/resources/__init__.py

@@ -5,28 +5,30 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import importlib.resources as pkg_resources
 from pathlib import Path
 
-resource_dir = Path(__file__).parent
-
-CONTAINERFILE = resource_dir / "Containerfile"
+from . import fm_tools, properties
 
 # During the build of the wheel file, the fm-tools/data directory is copied
 # to the wheel file under fm_weck/resources/fm_tools
-FM_DATA_LOCATION = resource_dir / "fm_tools"
-PROPERTY_LOCATION = resource_dir / "properties"
+
 RUN_WITH_OVERLAY = "run_with_overlay.sh"
-BENCHEXEC_WHL = resource_dir / "BenchExec-3.25-py3-none-any.whl"
+BENCHEXEC_WHL = "BenchExec-3.25-py3-none-any.whl"
 RUNEXEC_SCRIPT = "runexec"
 
 
 def iter_fm_data():
-    for fm_data in FM_DATA_LOCATION.iterdir():
-        if fm_data.is_file() and (fm_data.name.endswith(".yml") or fm_data.name.endswith(".yaml")):
-            yield fm_data
+    for fm_data in pkg_resources.contents(fm_tools):
+        with pkg_resources.path(fm_tools, fm_data) as fake_context_path:
+            fm_data_path = Path(fake_context_path)
+            if fm_data_path.is_file() and (fm_data_path.name.endswith(".yml") or fm_data_path.name.endswith(".yaml")):
+                yield fm_data_path
 
 
 def iter_properties():
-    for prop in PROPERTY_LOCATION.iterdir():
-        if prop.is_file():
-            yield prop
+    for prop in pkg_resources.contents(properties):
+        with pkg_resources.path(properties, prop) as fake_context_path:
+            prop_path = Path(fake_context_path)
+            if prop_path.is_file():
+                yield prop_path

fm_weck/resources/fm_tools/2ls.yml

@@ -1,5 +1,13 @@
 id: 2ls
 name: 2LS
+description: |
+  2LS ("tools") is a verification tool for C programs, built upon the CPROVER framework. 
+  It allows one to verify user-specified assertions, undefined behaviour, memory leaks, 
+  and termination properties. The analysis is performed by translating the verification 
+  task into a second-order logic formula over bitvector, array, and floating-point
+  arithmetic theories. The formula is solved by a modular combination of algorithms 
+  involving unfolding and template-based invariant synthesis with the help of
+  incremental SAT solving.
 input_languages:
   - C
 project_url: https://github.com/diffblue/2ls
@@ -69,21 +77,38 @@ techniques:
   - Shape Analysis
   - Bit-Precise Analysis
   - Ranking Functions
+  - Template-Based Predicate Inference
 
 frameworks_solvers:
   - CProver
   - MiniSAT
+  - Glucose
 
 literature:
   - doi: 10.1007/978-3-662-48288-9_9
     title: "Safety Verification and Refutation by k-Invariants and k-Induction"
     year: 2015
-  - doi: 10.1007/978-3-031-30820-8_31
-    title: "2ls: Arrays and Loop Unwinding (Competition Contribution)"
-    year: 2023
+  - doi: 10.1007/978-3-662-49674-9_56
+    title: "2LS for Program Analysis (Competition Contribution)"
+    year: 2016
+  - doi: 10.1145/3121136
+    title: Bit-Precise Procedure-Modular Termination Analysis
+    year: 2018
+  - doi: 10.1007/978-3-319-89963-3_24
+    title: "2LS: Memory Safety and Non-termination - (Competition Contribution)"
+    year: 2018
+  - doi: 10.23919/FMCAD.2018.8603009
+    title: Template-Based Verification of Heap-Manipulating Programs
+    year: 2019
   - doi: 10.1007/978-3-030-45237-7_22
-    title: "2ls: Heap Analysis and Memory Safety (Competition Contribution)"
+    title: "2LS: Heap Analysis and Memory Safety (Competition Contribution)"
     year: 2020
-  - doi: 10.1007/978-3-662-49674-9_56
-    title: "2ls for Program Analysis (Competition Contribution)"
-    year: 2016
+  - doi: 10.1007/978-3-031-30820-8_31
+    title: "2LS: Arrays and Loop Unwinding (Competition Contribution)"
+    year: 2023
+  - doi: 10.48550/arXiv.2302.02380
+    title: "2LS for Program Analysis"
+    year: 2023
+  - doi: 10.1007/978-3-031-56222-8_12
+    title: Template-Based Verification of Array-Manipulating Programs
+    year: 2024

fm_weck/resources/fm_tools/aise.yml

@@ -1,5 +1,8 @@
 id: aise
 name: aise
+description: |
+  AISE is a software verifer that verifes C programs with respect to reachability properties. 
+  The key idea of AISE is to synergize symbolic execution (SE) and abstract interpretation (AI).
 input_languages:
   - C
 project_url: https://github.com/zbchen/aise-verifier
@@ -50,7 +53,9 @@ competition_participations:
 techniques:
   - Symbolic Execution
 
-frameworks_solvers: []
+frameworks_solvers:
+  - CVC
+  - Z3
 
 literature:
   - doi: 10.1007/978-3-031-57256-2_19

fm_weck/resources/fm_tools/aprove.yml

@@ -1,73 +1,74 @@
 id: aprove
-name: AProVE (KoAT + LoAT)
-input_languages:
-  - C
-project_url: https://aprove.informatik.rwth-aachen.de/
-spdx_license_identifier: AProVE license
-benchexec_toolinfo_module: benchexec.tools.aprove
-fmtools_format_version: "2.0"
-fmtools_entry_maintainers:
-  - nilslommen
-  - JCKassing
-
-maintainers:
-  - orcid: 0000-0003-3187-9217
-    name: Nils Lommen
-    institution: RWTH Aachen
-    country: Germany
-    url: https://verify.rwth-aachen.de/nlommen/
-  - orcid: 0009-0001-9972-2470
-    name: Jan-Christoph Kassing
-    institution: RWTH Aachen
-    country: Germany
-    url: https://verify.rwth-aachen.de/jckassing/
-
-versions:
-  - version: "svcomp25"
-    doi: "10.5281/zenodo.14192730"
-    benchexec_toolinfo_options: []
-    required_ubuntu_packages:
-      - openjdk-17-jre-headless
-    base_container_images:
-      - docker.io/ubuntu:20.04
-    full_container_images:
-      - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/user:2022
-  - version: "svcomp22"
-    url: "https://gitlab.com/sosy-lab/sv-comp/archives-2022/raw/svcomp22/2022/aprove.zip"
-    benchexec_toolinfo_options: []
-    required_ubuntu_packages: []
-    base_container_images:
-      - docker.io/ubuntu:20.04
-    full_container_images:
-      - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/user:2022
-
-competition_participations:
-  - competition: "SV-COMP 2025"
-    track: "Verification"
-    tool_version: "svcomp25"
-    jury_member:
-      orcid: 0000-0003-3187-9217
-      name: Nils Lommen
-      institution: RWTH Aachen
-      country: Germany
-      url: https://verify.rwth-aachen.de/nlommen/
-  - competition: "SV-COMP 2022"
-    track: "Verification"
-    tool_version: "svcomp22"
-    jury_member:
-      orcid: 0000-0003-2852-9830
-      name: Jera Hensel
-      institution: RWTH Aachen
-      country: Germany
-      url: https://verify.rwth-aachen.de/jhensel/
-
-techniques:
-  - Ranking Functions
-
-frameworks_solvers:
-  - Z3
-
-literature:
-  - doi: 10.1007/978-3-030-99527-0_21
-    title: "AProVE: Non-Termination Witnesses for C Programs (Competition Contribution)"
-    year: 2022
+name: AProVE (KoAT + LoAT)
+description: AProVE (KoAT + LoAT) is a system for automated termination proofs for C / LLVM programs. To (dis)prove termination of C programs, AProVE uses symbolic execution to transform the program's LLVM code into an integer transition system (ITS). These ITSs are analyzed by our backend tools KoAT (for termination) and LoAT (for non-termination).
+input_languages:
+  - C
+project_url: https://aprove.informatik.rwth-aachen.de/
+spdx_license_identifier: LicenseRef-AProVE
+benchexec_toolinfo_module: benchexec.tools.aprove
+fmtools_format_version: "2.0"
+fmtools_entry_maintainers:
+  - nilslommen
+  - JCKassing
+
+maintainers:
+  - orcid: 0000-0003-3187-9217
+    name: Nils Lommen
+    institution: RWTH Aachen
+    country: Germany
+    url: https://verify.rwth-aachen.de/nlommen/
+  - orcid: 0009-0001-9972-2470
+    name: Jan-Christoph Kassing
+    institution: RWTH Aachen
+    country: Germany
+    url: https://verify.rwth-aachen.de/jckassing/
+
+versions:
+  - version: "svcomp25"
+    doi: "10.5281/zenodo.14192730"
+    benchexec_toolinfo_options: []
+    required_ubuntu_packages:
+      - openjdk-17-jre-headless
+    base_container_images:
+      - docker.io/ubuntu:20.04
+    full_container_images:
+      - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/user:2022
+  - version: "svcomp22"
+    url: "https://gitlab.com/sosy-lab/sv-comp/archives-2022/raw/svcomp22/2022/aprove.zip"
+    benchexec_toolinfo_options: []
+    required_ubuntu_packages: []
+    base_container_images:
+      - docker.io/ubuntu:20.04
+    full_container_images:
+      - registry.gitlab.com/sosy-lab/benchmarking/competition-scripts/user:2022
+
+competition_participations:
+  - competition: "SV-COMP 2025"
+    track: "Verification"
+    tool_version: "svcomp25"
+    jury_member:
+      orcid: 0000-0003-3187-9217
+      name: Nils Lommen
+      institution: RWTH Aachen
+      country: Germany
+      url: https://verify.rwth-aachen.de/nlommen/
+  - competition: "SV-COMP 2022"
+    track: "Verification"
+    tool_version: "svcomp22"
+    jury_member:
+      orcid: 0000-0003-2852-9830
+      name: Jera Hensel
+      institution: RWTH Aachen
+      country: Germany
+      url: https://verify.rwth-aachen.de/jhensel/
+
+techniques:
+  - Ranking Functions
+
+frameworks_solvers:
+  - Z3
+
+literature:
+  - doi: 10.1007/978-3-030-99527-0_21
+    title: "AProVE: Non-Termination Witnesses for C Programs (Competition Contribution)"
+    year: 2022

fm_weck/resources/fm_tools/blast.yml

@@ -0,0 +1,58 @@
+id: blast
+name: BLAST
+input_languages:
+  - C
+project_url: http://forge.ispras.ru/projects/blast
+repository_url: https://forge.ispras.ru/projects/blast/repository
+spdx_license_identifier: Apache-2.0
+benchexec_toolinfo_module: "https://gitlab.com/sosy-lab/software/benchexec/-/raw/main/benchexec/tools/blast.py"
+fmtools_format_version: "2.0"
+fmtools_entry_maintainers:
+  - dbeyer
+
+maintainers:
+  - orcid: 0000-0003-3097-8512
+    name: Vadim Mutilin
+    institution: ISP RAS
+    country: Russia
+    url: http://forge.ispras.ru/users/29
+
+versions:
+  - version: "svcomp17-zip"
+    doi: 10.5281/zenodo.14535214
+    benchexec_toolinfo_options: ["-alias", "empty", "-enable-recursion", "-noprofile", "-cref", "-sv-comp", "-lattice", "-include-lattice", "symb", "-nosserr", "-svcomp-witness", "error-witness.graphml"]
+    required_ubuntu_packages: []
+    full_container_images: []
+
+competition_participations:
+  - competition: "SV-COMP 2017"
+    track: "Verification"
+    tool_version: "svcomp17-zip"
+    jury_member:
+      orcid: 0000-0003-3097-8512
+      name: Vadim Mutilin
+      institution: ISP RAS
+      country: Russia
+      url: http://forge.ispras.ru/users/29
+
+techniques:
+  - CEGAR
+  - Predicate Abstraction
+  - Explicit-Value Analysis
+  - ARG-Based Analysis
+  - Lazy Abstraction
+  - Interpolation
+
+frameworks_solvers:
+  - CSIsat
+
+literature:
+  - doi: 10.1007/s10009-007-0044-z
+    title: "The software model checker Blast"
+    year: 2007
+  - doi: 10.1134/S0361768812030061
+    title: "Experience of improving the blast static verification tool"
+    year: 2012
+  - doi: 10.1007/978-3-642-28756-5_39
+    title: "Predicate Analysis with BLAST 2.7 (Competition Contribution)"
+    year: 2012

fm_weck/resources/fm_tools/brick.yml

@@ -15,7 +15,7 @@ maintainers:
     name: Lei Bu
     institution: Nanjing University
     country: China
-    url: null
+    url:
 
 versions:
   - version: "svcomp25"
@@ -40,7 +40,7 @@ competition_participations:
       name: Lei Bu
       institution: Nanjing University
       country: China
-      url: null
+      url:
   - competition: "SV-COMP 2024"
     track: "Verification"
     tool_version: "svcomp24"
@@ -49,7 +49,7 @@ competition_participations:
       name: Lei Bu
       institution: Nanjing University
       country: China
-      url: null
+      url:
   - competition: "SV-COMP 2023"
     track: "Verification"
     tool_version: "svcomp23"
@@ -58,7 +58,7 @@ competition_participations:
       name: Lei Bu
       institution: Nanjing University
       country: China
-      url: null
+      url:
 
 techniques:
   - CEGAR