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

fm_weck/__init__.py

@@ -8,4 +8,4 @@
 from .config import Config  # noqa: F401
 from .image_mgr import ImageMgr  # noqa: F401
 
-__version__ = "1.4.6"
+__version__ = "1.4.7"

fm_weck/cli.py

@@ -13,23 +13,25 @@ from argparse import Namespace
 from dataclasses import dataclass
 from functools import cache
 from pathlib import Path
-from typing import Any, Callable, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
 
 try:
     from fm_tools.benchexec_helper import DataModel
 except ImportError:
     from enum import Enum
 
-    class DataModel(Enum):
-        """
-        Enum representing the data model of the tool.
-        """
+    if not TYPE_CHECKING:
 
-        LP64 = "LP64"
-        ILP32 = "ILP32"
+        class DataModel(Enum):
+            """
+            Enum representing the data model of the tool.
+            """
 
-        def __str__(self):
-            return self.value
+            LP64 = "LP64"
+            ILP32 = "ILP32"
+
+            def __str__(self):
+                return self.value
 
 
 import contextlib
@@ -107,7 +109,7 @@ class ShellCompletion:
         return selected_tools
 
 
-def add_tool_arg(parser, nargs="?"):
+def add_tool_arg(parser, nargs: str | None = "?"):
     parser.add_argument(
         "TOOL",
         help="The tool to obtain the container from. Can be the form <tool>:<version>. "
@@ -196,7 +198,7 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         ),
         required=False,
         default=None,
-    ).completer = ShellCompletion.properties_completer
+    ).completer = ShellCompletion.properties_completer  # type: ignore[assignment]
 
     run.add_argument(
         "-d",
@@ -313,7 +315,7 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         help="The tool(s) for which to print the versions.",
         type=ToolQualifier,
         nargs="+",
-    ).completer = ShellCompletion.versions_completer
+    ).completer = ShellCompletion.versions_completer  # type: ignore[assignment]
     versions.set_defaults(main=main_versions)
 
     with contextlib.suppress(ImportError):
@@ -368,7 +370,7 @@ def resolve_tool(tool: ToolQualifier) -> Path:
     if (as_path := Path(tool_name)).exists() and as_path.is_file():
         return as_path
 
-    return fm_tools_choice_map()[tool_name]
+    return fm_tools_choice_map()[str(tool_name)]
 
 
 def resolve_property(prop_name: str) -> Path:
@@ -459,10 +461,7 @@ def main_manual(args: argparse.Namespace):
 
 
 def main_install(args: argparse.Namespace):
-    from .serve import setup_fm_tool
-
-    if args.destination:
-        Config()._config["defaults"]["cache_location"] = args.destination.resolve()
+    from .serve import install_fm_tool
 
     for tool in args.TOOL:
         try:
@@ -471,10 +470,11 @@ def main_install(args: argparse.Namespace):
             logger.error("Unknown tool %s. Skipping installation...", tool)
             continue
 
-        setup_fm_tool(
+        install_fm_tool(
             fm_tool=fm_data,
             version=tool.version,
             configuration=Config(),
+            install_path=args.destination
         )
 
     return 0
@@ -499,9 +499,9 @@ def main_shell(args: argparse.Namespace):
 
 def main_clear_cache(args: argparse.Namespace):
     if args.yes:
-        clear_cache(Config().get("defaults").get("cache_location"))
+        clear_cache(Config().get("defaults", {}).get("cache_location"))  # type: ignore
     else:
-        ask_and_clear(Config().get("defaults").get("cache_location"))
+        ask_and_clear(Config().get("defaults", {}).get("cache_location"))  # type: ignore
     return
 
 

fm_weck/config.py

@@ -13,21 +13,29 @@ import stat
 import sys
 from functools import cache
 from pathlib import Path
-from typing import Any, Callable, Iterable, Optional, Tuple, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, Tuple, TypeVar
+
+from werkzeug.utils import secure_filename
 
 try:
-    from fm_tools.fmdata import FmData
+    from fm_tools.fmtool import FmTool
+    from fm_tools.fmtoolversion import FmToolVersion
 except ImportError:
+    if not TYPE_CHECKING:
+
+        class FmTool:
+            def __init__(self, data):
+                raise ImportError("fm_tools is not imported.")
 
-    class FmData:
-        def __init__(self, data, version):
-            raise ImportError("fm_tools is not imported.")
+        class FmToolVersion:
+            def __init__(self, data: FmTool, version: str):
+                raise ImportError("fm_tools is not imported.")
 
-        def get_actor_name(self):
-            raise ImportError("fm_tools is not imported.")
+            def get_actor_name(self):
+                raise ImportError("fm_tools is not imported.")
 
-        def get_version(self):
-            raise ImportError("fm_tools is not imported.")
+            def get_version(self):
+                raise ImportError("fm_tools is not imported.")
 
 
 from fm_weck.resources import RUN_WITH_OVERLAY, RUNEXEC_SCRIPT
@@ -35,7 +43,7 @@ from fm_weck.resources import RUN_WITH_OVERLAY, RUNEXEC_SCRIPT
 try:
     import tomllib as toml
 except ImportError:
-    import tomli as toml
+    import tomli as toml  # type: ignore
 
 _SEARCH_ORDER: tuple[Path, ...] = (
     Path.cwd() / ".fm-weck",
@@ -121,7 +129,7 @@ class Config(object):
         return self.defaults().get(key, None)
 
     @staticmethod
-    def _handle_relative_paths(fn: Callable[[Any], Path]) -> Callable[[Any], Path]:
+    def _handle_relative_paths(fn: Callable[..., Path]) -> Callable[..., Path]:
         def wrapper(self, *args, **kwargs) -> Path:
             """Makes sure relative Paths in the config are relative to the config file."""
 
@@ -159,9 +167,15 @@ class Config(object):
     def get_checksum_db(self) -> Path:
         return self.cache_location / ".checksums.dbm"
 
-    def get_shelve_space_for(self, fm_data: FmData) -> Path:
+    def get_shelve_space_for(self, fm_data: FmToolVersion) -> Path:
         shelve = self.cache_location
-        tool_name = fm_data.get_actor_name()  # safe to use in filesystem
+        # Remove leading http:// or https:// from the raw archive location
+        raw_location = fm_data.get_archive_location().raw
+        if raw_location.startswith("http://"):
+            raw_location = raw_location[len("http://") :]
+        elif raw_location.startswith("https://"):
+            raw_location = raw_location[len("https://") :]
+        tool_name = secure_filename(raw_location)
         return shelve / tool_name
 
     def get_shelve_path_for_property(self, path: Path) -> Path:
@@ -179,10 +193,10 @@ class Config(object):
     def _system_is_not_posix():
         return not (sys.platform.startswith("linux") or sys.platform == "darwin")
 
-    def make_runexec_script_available(self) -> Path:
+    def make_runexec_script_available(self) -> Path | None:
         return self.make_script_available(RUNEXEC_SCRIPT)
 
-    def make_script_available(self, target_name: str = RUN_WITH_OVERLAY) -> Path:
+    def make_script_available(self, target_name: str = RUN_WITH_OVERLAY) -> Path | None:
         script_dir = self.cache_location / ".scripts"
         target = script_dir / target_name
 
@@ -224,7 +238,7 @@ class Config(object):
 
 
 @cache
-def parse_fm_data(fm_data: Path, version: Optional[str]) -> FmData:
+def parse_fm_data(fm_data: Path, version: str | None) -> FmToolVersion:
     import yaml
 
     if not fm_data.exists() or not fm_data.is_file():
@@ -233,4 +247,4 @@ def parse_fm_data(fm_data: Path, version: Optional[str]) -> FmData:
     with fm_data.open("rb") as f:
         data = yaml.safe_load(f)
 
-    return FmData(data, version)
+    return FmToolVersion(data, version)

fm_weck/engine.py

@@ -15,20 +15,25 @@ from abc import ABC, abstractmethod
 from functools import cached_property, singledispatchmethod
 from pathlib import Path
 from tempfile import mkdtemp
-from typing import Callable, 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
@@ -157,7 +162,7 @@ class Engine(ABC):
                 except shutil.Error as e:
                     logger.warning(f"Error while copying the output {file} directory: {e}")
 
-    def assemble_command(self, command: tuple[str, ...]) -> list[str]:
+    def assemble_command(self, command: Iterable[str]) -> list[str]:
         base = self.base_command()
         if self.add_benchexec_capabilities:
             base += self.benchexec_capabilities()
@@ -180,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."""
 
@@ -218,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):
@@ -241,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)
@@ -249,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)
@@ -281,6 +286,8 @@ class Engine(ABC):
 
     class BuildCommand(ABC):
         build_args: List[str] = []
+        containerfile: Path
+        _engine: str
 
         @abstractmethod
         def __init__(self, containerfile: Path, **kwargs):
@@ -290,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
 
@@ -342,7 +349,7 @@ class Engine(ABC):
             process.terminate()
             process.wait()
 
-        return RunResult(command, process.returncode, io.StringIO())
+        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
@@ -363,16 +370,18 @@ class Engine(ABC):
 
         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:
-            run_and_poll(full_stdout.write)
+            run_and_poll(full_stdout.write)  # type: ignore
         else:
             with self.log_file.open("w") as log:
-                run_and_poll(log.write)
+                run_and_poll(log.write)  # type: ignore
 
         assert process is not None, "Process should be defined at this point."
         try:
@@ -391,12 +400,12 @@ class Engine(ABC):
         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)

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.27-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/cadp.yml

@@ -17,7 +17,7 @@ fmtools_entry_maintainers:
   - dbeyer
 
 maintainers:
-  - orcid: 0000-0000-0000-0000
+  - orcid: 0009-0000-5304-8081
     name: Hubert Garavel
     institution: INRIA
     country: France

fm_weck/resources/fm_tools/hybridtiger.yml

@@ -2,7 +2,7 @@ id: hybridtiger
 name: HybridTiger
 input_languages:
   - C
-project_url: https://www.es.tu-darmstadt.de/es/team/sebastian-ruland/testcomp20
+project_url: https://gitlab.com/sosy-lab/software/cpachecker
 repository_url: https://gitlab.com/sosy-lab/software/cpachecker
 spdx_license_identifier: Apache-2.0
 benchexec_toolinfo_module: "https://gitlab.com/sosy-lab/software/benchexec/-/raw/main/benchexec/tools/cpachecker.py"

fm_weck/resources/fm_tools/ltsmin.yml

@@ -0,0 +1,40 @@
+id: ltsmin
+name: LTSmin
+description: |
+  LTSmin is a language-independent model-checking toolset supporting
+  multiple input languages and advanced state-space generation techniques via a unified PINS interface. 
+  It features modular architecture, symbolic/distributed/multi-core reachability,
+  and easy extensibility for new languages.
+input_languages:
+  - PNML
+project_url: https://ltsmin.utwente.nl/
+repository_url: https://github.com/utwente-fmt/ltsmin
+spdx_license_identifier: BSD-3-Clause
+benchexec_toolinfo_module: "https://www.cip.ifi.lmu.de/~wachowitz/ltsmin.py"
+fmtools_format_version: "2.0"
+fmtools_entry_maintainers:
+  - dbeyer
+  - ricffb
+
+maintainers:
+  - orcid: 0000-0002-2433-4174
+    name: Alfons Laarman
+    institution: Leiden Institute for Advanced Computer Science
+    country: Netherlands
+    url: https://alfons.laarman.com/
+
+versions:
+  - version: "pnml2lts-sym-3.0.2"
+    url: "https://github.com/utwente-fmt/ltsmin/releases/download/v3.0.2/ltsmin-v3.0.2-linux.tgz"
+    benchexec_toolinfo_options: ["pnml2lts-sym"]
+    required_ubuntu_packages: []
+    base_container_image: ["ubuntu:24.04"]
+
+competition_participations: []
+
+techniques: []
+
+frameworks_solvers: []
+
+literature: []
+

fm_weck/resources/fm_tools/sv-sanitizers.yml

@@ -1,5 +1,7 @@
 id: sv-sanitizers
-name: sv-sanitizers
+name: SV-sanitizers
+description: |
+  SV-COMP wrapper for sanitizers (ThreadSanitizer, AddressSanitizer, LeakSanitizer, UndefinedBehaviorSanitizer).
 input_languages:
   - C
 project_url: https://github.com/sim642/sv-sanitizers

fm_weck/run_result.py

@@ -10,13 +10,13 @@ from functools import singledispatchmethod
 
 from benchexec.tools.template import BaseTool2
 from benchexec.util import ProcessExitCode
-from fm_tools import FmData
+from fm_tools.fmtoolversion import FmToolVersion
 from fm_tools.run import get_tool_info
 
 
 @dataclass(frozen=True)
 class RunResult:
-    command: tuple[str, ...]
+    command: tuple[str, ...] | list[str]
     exit_code: int
     raw_output: str
 
@@ -33,6 +33,6 @@ class RunResult:
         return tool.determine_result(self.as_benchexec_run())
 
     @determine_result.register
-    def _(self, tool: FmData) -> str:
-        tool = get_tool_info(tool)
-        return self.determine_result(tool)
+    def _(self, tool: FmToolVersion) -> str:
+        tool_ = get_tool_info(tool)
+        return self.determine_result(tool_)

fm_weck/runexec_mode.py

@@ -5,6 +5,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import importlib.resources as pkg_resources
 import logging
 import shutil
 from pathlib import Path
@@ -42,8 +43,13 @@ def run_runexec(
     else:
         # Default to the bundled benchexec package
         benchexec_package = configuration.get_shelve_path_for_benchexec()
-        shutil.copyfile(BENCHEXEC_WHL, benchexec_package)
-        engine.env["PYTHONPATH"] = f"{CACHE_MOUNT_LOCATION}/.lib/benchexec.whl"
+        try:
+            with pkg_resources.path("fm_weck.resources", BENCHEXEC_WHL) as source_path:
+                shutil.copy(source_path, benchexec_package)
+            engine.env["PYTHONPATH"] = f"{CACHE_MOUNT_LOCATION}/.lib/benchexec.whl"
+        except FileNotFoundError:
+            logging.error(f"Resource {BENCHEXEC_WHL} not found in package.")
+            return None
 
     for path in mountable_absolute_paths_of_command(Path.cwd().absolute(), command):
         engine.mount(path, str(path) + ":ro")

fm_weck/serve.py

@@ -6,6 +6,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import dbm
+import json
 import logging
 import os
 import shutil
@@ -13,8 +14,8 @@ import sys
 from pathlib import Path
 from typing import Optional, Tuple, Union
 
-from fm_tools import FmData
 from fm_tools.benchexec_helper import DataModel
+from fm_tools.fmtoolversion import FmToolVersion
 
 from fm_weck.run_result import RunResult
 
@@ -60,12 +61,12 @@ def update_checksum(shelve_space: Path, checksum: str, config: Config):
 
 
 def setup_fm_tool(
-    fm_tool: Union[Path, FmData],
+    fm_tool: Union[Path, FmToolVersion],
     version: Optional[str],
     configuration: Config,
     offline_mode: bool = False,
-) -> Tuple[FmData, Path]:
-    # Don't explicitly disallow non-FmData here; Pythonic Users might want to exchange the FmData object
+) -> Tuple[FmToolVersion, Path]:
+    # Don't explicitly disallow non-FmToolVersion here; Pythonic Users might want to exchange the FmToolVersion object
     # by a class with the same interface
     fm_data = parse_fm_data(fm_tool, version) if isinstance(fm_tool, (Path, str)) else fm_tool
 
@@ -75,14 +76,23 @@ def setup_fm_tool(
 
     if (not offline_mode) and shelve_space.exists() and shelve_space.is_dir():
         logger.debug("Shelve space already exists, testing checksum")
-        checksum = fm_data.archive_location.checksum()
-        skip_download = check_cache_entry(shelve_space, checksum, configuration)
+        checksum = fm_data.get_archive_location().resolve().checksum
+        if checksum is None:
+            logger.warning("No checksum available for %s, skipping cache check", fm_data.get_tool_name_with_version())
+            skip_download = False
+        else:
+            skip_download = check_cache_entry(shelve_space, checksum, configuration)
 
     if not skip_download:
         fm_data.download_and_install_into(shelve_space)
-        checksum = fm_data.archive_location.checksum()
-        update_checksum(shelve_space, checksum, configuration)
-
+        checksum = fm_data.get_archive_location().resolve().checksum
+        if checksum is None:
+            logger.warning(
+                "No checksum available for %s, skipping checksum update", fm_data.get_tool_name_with_version()
+            )
+        else:
+            update_checksum(shelve_space, checksum, configuration)
+        map_doi(fm_data, shelve_space)
     tool_info_module = fm_data.get_toolinfo_module()
 
     if (not offline_mode) or tool_info_module._trivially_resolved():
@@ -98,8 +108,18 @@ def setup_fm_tool(
     return fm_data, shelve_space
 
 
+def install_fm_tool(
+    fm_tool: Union[Path, FmToolVersion], version: Optional[str], configuration: Config, install_path: Path
+) -> None:
+    fm_data = parse_fm_data(fm_tool, version) if isinstance(fm_tool, (Path, str)) else fm_tool
+    shelve_space = install_path.resolve() if install_path else configuration.get_shelve_space_for(fm_data)
+
+    logger.debug("Installing tool into %s", shelve_space)
+    fm_data.download_and_install_into(shelve_space)
+
+
 def run_guided(
-    fm_tool: Union[Path, FmData],
+    fm_tool: Union[Path, FmToolVersion],
     version: Optional[str],
     configuration: Config,
     prop: Optional[Path],
@@ -123,7 +143,7 @@ def run_guided(
             shutil.copyfile(source_property_path, property_path)
         except KeyError:
             logger.error("Unknown property %s", prop)
-            return 1, None
+            return RunResult(command=[], exit_code=1, raw_output="Unknown property")
 
     configuration.make_script_available()
 
@@ -157,7 +177,7 @@ def run_guided(
     # We are using the second approach here, in order to avoid modifying FM-Data
     if witness is not None:
         assert any(c == "${witness}" for c in command), "The version given does not support witness files"
-        command = [witness if c == "${witness}" else c for c in command]
+        command = [str(witness) if c == "${witness}" else c for c in command]
 
     logger.debug("Assembled command from fm-tools: %s", command)
 
@@ -169,7 +189,7 @@ def run_guided(
 
 
 def run_manual(
-    fm_tool: Union[Path, FmData],
+    fm_tool: Union[Path, FmToolVersion],
     version: Optional[str],
     configuration: Config,
     command: list[str],
@@ -200,6 +220,29 @@ def run_manual(
 
     engine.print_output_to_stdout = print_tool_output_to_console
 
-    execution_result = engine.run(executable, *command, timeout_sec=timeout_sec)
+    execution_result = engine.run(str(executable), *command, timeout_sec=timeout_sec)
 
     return execution_result
+
+
+### Move to cache_mgr.py after merge to main ###
+def map_doi(fm_data: FmToolVersion, tool_path: Path):
+    doi_map = tool_path.parent / "doi_map.json"
+
+    if os.path.exists(doi_map):
+        with open(doi_map, "r") as file:
+            data = json.load(file)
+    else:
+        data = {}
+
+    doi = str(tool_path).split("/")[-1]
+    if doi not in data:
+        data[doi] = []
+    if fm_data.get_tool_name_with_version() not in data[doi]:
+        data[doi].append(fm_data.get_tool_name_with_version())
+
+    with open(doi_map, "w") as file:
+        json.dump(data, file, indent=2)
+
+
+### Move to cache_mgr.py after merge to main ###

{fm_weck-1.4.6.dist-info → fm_weck-1.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fm-weck
-Version: 1.4.6
+Version: 1.4.7
 Author-email: Henrik Wachowitz <henrik.wachowitz@ifi.lmu.de>
 Maintainer-email: Henrik Wachowitz <henrik.wachowitz@ifi.lmu.de>
 Classifier: Development Status :: 4 - Beta
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Requires-Dist: argcomplete
-Requires-Dist: fm-tools>=0.3.3
+Requires-Dist: fm-tools>=1.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tabulate
 Requires-Dist: tomli>=2.0; python_version <= '3.10'

{fm_weck-1.4.6.dist-info → fm_weck-1.4.7.dist-info}/RECORD

@@ -1,20 +1,20 @@
-fm_weck/__init__.py,sha256=DV5C4Bm7M37AnsKAzMOPeyxn9kt_BMFQM69KKWhiOos,351
+fm_weck/__init__.py,sha256=qVPurJ_oj0SwP8asFRG0x8Qh7KDzNBLJf5jHKxcyDMc,351
 fm_weck/__main__.py,sha256=IfNDAqM6MK6P7KsQoW3wOHPOscB8evdVlS9C7R4wd_0,391
 fm_weck/cache_mgr.py,sha256=3-OQFmCeswazXmX08ND4oEHFOR07ZDCwWzjmFTDkOSE,1373
-fm_weck/cli.py,sha256=3XfzaMqh2Bl_Es3n_7Kv80LScJmQdI6et0tcEI_Z2W4,17069
-fm_weck/config.py,sha256=AAp5qPZfx2Gh-43jySzfHzHOEmbduHJalA7guV9SIzI,7340
-fm_weck/engine.py,sha256=PfcjtN-szlpinSFtv1uE0zs_w__GvR8BSlqbz0u6lII,16742
+fm_weck/cli.py,sha256=k2-rHURw_w0yy5L97FofJ0jYVxqpNP79_XTtirYbyjY,17194
+fm_weck/config.py,sha256=72HfwKJlLnyrBUmLyjEebgPerGMq0CdnQnugz1SIWis,8017
+fm_weck/engine.py,sha256=1EhfL0tzgVyBNf4b40yt2w1netv2Elyop9aRpwzCvm0,17262
 fm_weck/exceptions.py,sha256=xXxbYK-FZW6YksBtaN79KaA4fGnFCBO-wc0QMqtq3Og,282
-fm_weck/image_mgr.py,sha256=f1RlmQPBiMrsqPyH1Rtfb8WMp2YBq-7z-Rto_kCfS7U,1861
-fm_weck/run_result.py,sha256=b7t_g6qN2GFGPW6cCoLX_BWMSQ_Q-1cca3Fw3lmIB9M,1207
-fm_weck/runexec_mode.py,sha256=vV90CfxwvoR1ApwL4BXq2q_7f8wjSFsS5XQyugDFWMQ,1909
+fm_weck/image_mgr.py,sha256=mDqP-YD6AEOW2xldYJ4D-wxYKF0Ta5SgoJiX2CrhyQg,1906
+fm_weck/run_result.py,sha256=0d8G3py1VCPP4jLxPCVzL8Vljvrwt9IHlmvCkW0pwx8,1249
+fm_weck/runexec_mode.py,sha256=UamxVvYm0XErPjR2sRJaLMX8uHBzRcgCTWbQIZjdju0,2195
 fm_weck/runexec_util.py,sha256=YBvVIPpmEousZVxbZ5NS8jzpKPLyws31kIFE2z3Ki2E,1370
-fm_weck/serve.py,sha256=JaaOi2ipJbPiATHVcpjXOoE8XyuoWXSFlrKtdfkqjU8,7342
+fm_weck/serve.py,sha256=RL6LOnK0RMhFRWehwFdoydc0A619FqSaph7H0JFDYlo,9037
 fm_weck/version_listing.py,sha256=caaoC3n9R-Ao2sEQ_ngOVO3bnKr7cNVeH6EiA8jO5Sc,864
 fm_weck/resources/BenchExec-3.27-py3-none-any.whl,sha256=g-db8LM8HfqLhbnl7n5lvUbMnF2tZ4MHAVOxTGxqO8w,732849
 fm_weck/resources/BenchExec-3.27-py3-none-any.whl.license,sha256=Nq2Mwgn_pyr6ZZrTT095QPtFP3hr15ZeIRIaY0B7eC8,201
 fm_weck/resources/Containerfile,sha256=MltxP1of9klsQFNR8WyngRTJrPwxQTF4C9ennRxVqSo,391
-fm_weck/resources/__init__.py,sha256=XRQiBOncbVvTqZkJ6vSuvu5SUYd3zEV-dGHZTmmLsEM,1023
+fm_weck/resources/__init__.py,sha256=-YLqFTF2Gu4RA9ye3SdvBk1rjhlYxk_f1TgPsix3SAk,1213
 fm_weck/resources/run_with_overlay.sh,sha256=v1gV_6kMQ0v9BQ3chgDqI1MAOLHbPWeeTC52aCqVpEM,1162
 fm_weck/resources/runexec,sha256=ogIBO38HLu9C9kDTTANBgAqVnH-UIF1bSJ9d3DSjyF4,462
 fm_weck/resources/properties/coverage-branches.prp,sha256=Gl2r1cgBFoh4M2laa8dVGhteHkL04oiBRLzxz_hbkEU,56
@@ -46,7 +46,7 @@ fm_weck/resources/fm_tools/blast.yml,sha256=zwPhJN0PfNJo_ZM4a5DNTxKCqc_b0CDaADRf
 fm_weck/resources/fm_tools/brick.yml,sha256=7mWXlRdc-XiFR2c2wohhuoWHCznmEcnr1i1aLCtcZTk,2007
 fm_weck/resources/fm_tools/bubaak-split.yml,sha256=7hmY5CYgIdQJAXYrpcGwR-3tqDFnQNTemFUforrDojQ,1886
 fm_weck/resources/fm_tools/bubaak.yml,sha256=pcJCljIHYmgEMOdeMp8YQxAURO0WlLQ-FpYlYktQHLw,2171
-fm_weck/resources/fm_tools/cadp.yml,sha256=nJsmaBl4qwLsP_ZKujCY7Gbjc0qWV6FbmErpPPw1f2c,3352
+fm_weck/resources/fm_tools/cadp.yml,sha256=xkXVGEn4PYMK7ItnaleVLOvbmAU8_9VDlqKjaln5C-k,3352
 fm_weck/resources/fm_tools/cbmc.yml,sha256=QfgJxq7aBhRcuQpR1_26wKvumM0H4JH7u3SQ_oXYyBM,2095
 fm_weck/resources/fm_tools/cetfuzz.yml,sha256=4JULcR2E0rM_RhgaFv9x8J34loMwB1uiluIKKcQninw,1808
 fm_weck/resources/fm_tools/coastal.yml,sha256=ebKhmUoTdlCTw6W4jIllpAJ-CSoFfGvaB004fDg17nY,1650
@@ -84,7 +84,7 @@ fm_weck/resources/fm_tools/graves-par.yml,sha256=GLoBUwv16gQBzrtg5dota5-wbls8Dd_
 fm_weck/resources/fm_tools/graves.yml,sha256=adyp-k_7moQ9pgSeCtEauPOGFIufWoRlQydIRjn0yi0,2269
 fm_weck/resources/fm_tools/gwit.yml,sha256=31k4Js4d3nCqW2uJDQnnfuqJcqfK77C0PuGBhdKMC98,1848
 fm_weck/resources/fm_tools/hornix.yml,sha256=zfJZg09qiueTtyDcZLpWEQDK8GhwfvjfbLI1G_tzUUM,1532
-fm_weck/resources/fm_tools/hybridtiger.yml,sha256=Zh9z-CQwB0tjF94_s4Yw9wnTblYAvumiwPk30-qfe_I,1833
+fm_weck/resources/fm_tools/hybridtiger.yml,sha256=4ieXZSbm5qdmW3hK5vSfIwOPW6ZI7rSmecE5Ql0xPpI,1814
 fm_weck/resources/fm_tools/infer.yml,sha256=sRIzRShUOhY_Y624Oiwdk5MR-c1ligXJdAgLdt-20qk,1884
 fm_weck/resources/fm_tools/java-ranger.yml,sha256=3T1Vq3v_7dBZl3oIgjZjoZVkPK-OGeFzoaxzpn8h4sE,1989
 fm_weck/resources/fm_tools/jayhorn.yml,sha256=4-R_2eBD_RvbY2f6Wsrp0ObssHdEsJT29aYCngYnozY,1994
@@ -101,6 +101,7 @@ fm_weck/resources/fm_tools/legion.yml,sha256=ClD8_UEJq8wHIEp9_ifhTNKJuNmzvekaQx1
 fm_weck/resources/fm_tools/lf-checker.yml,sha256=lV4-GzzNvzWW505FFtYAUHlSG4gxOn-LL4xT8Tpyvq0,1386
 fm_weck/resources/fm_tools/liv.yml,sha256=t0-Rfs0Ot3VPn7DD_pt3VAbyfpUOP8kdYV3E7uN3qGI,3260
 fm_weck/resources/fm_tools/locksmith.yml,sha256=c3wNvIzQ_PZaYv6Mm15QH-Rm4oTuNzILNJs1fssESYQ,1397
+fm_weck/resources/fm_tools/ltsmin.yml,sha256=vpfL4mBGlnxPtqoqaqUnR-Ph0kibaOd-h6FYuWHn91M,1206
 fm_weck/resources/fm_tools/metaval++.yml,sha256=KAOcvftDNLvuHzIKaUoebekeOxBE6DVS2Acq2VbL1Dg,2006
 fm_weck/resources/fm_tools/metaval.yml,sha256=aclr5cfGDuCduSrlk9kLOcK8GaUQAzPtDAxIJHgHs44,4668
 fm_weck/resources/fm_tools/mlb.yml,sha256=S_ykc9ThLHBbMSXOgYIvk81r96cEwXbAXI5lPRDxJ4s,1907
@@ -121,7 +122,7 @@ fm_weck/resources/fm_tools/rizzer.yml,sha256=ZmVL72-mBTzmMY29I3x5HmSCtQTMbJ0vw2U
 fm_weck/resources/fm_tools/schema.yml,sha256=_SqJzwFGxM0EuuLgcMF-S_hUtoGxaFKraGTfQDUyILY,22945
 fm_weck/resources/fm_tools/sikraken.yml,sha256=WnLxKyl-4zZ8rvXWqLuuqaC8b9GGQDg-jB3798SeK6M,1067
 fm_weck/resources/fm_tools/spf.yml,sha256=6-7306izjPHKcLZ1veQRmGWOVQcsFJbNyL_55JYVQXA,1692
-fm_weck/resources/fm_tools/sv-sanitizers.yml,sha256=tisvbuYRXutJuk-rsqzRJ-3NSMBL29hHjym3eqE4MAI,1431
+fm_weck/resources/fm_tools/sv-sanitizers.yml,sha256=bLG5MoLK95KruF5WCH0Yz2pJPAikPfkNgZRfbP5a2j0,1559
 fm_weck/resources/fm_tools/svf-svc.yml,sha256=gQ12F7_7uis7fVgsTiNdleKBgydi-BOgS4ne-dRyHvk,1591
 fm_weck/resources/fm_tools/swat.yml,sha256=gsvsFBeItbspzdXVVQ8TFWulbdYHzIHSmcKlWkWxGk0,1684
 fm_weck/resources/fm_tools/symbiotic-witch.yml,sha256=6ND-WISFvJEeyEB3Q-Xu71dZrc_ayr1kAnEzfV3TA84,2421
@@ -147,7 +148,7 @@ fm_weck/resources/fm_tools/wit4java.yml,sha256=ylfze2XbV4zKkVUH57Veqn7G49gW0Byxd
 fm_weck/resources/fm_tools/witch.yml,sha256=wwe6lrI2sxGKVZbLeipa38rPhB2pcSUFi9uVngtXGUQ,1795
 fm_weck/resources/fm_tools/witnesslint.yml,sha256=EvMBcm5fx6lgSLRmHSKXSxXIJKZ-BrxLwTXI4GQ6FMs,6812
 fm_weck/resources/fm_tools/witnessmap.yml,sha256=FyZtEloxpWBBjLn9kyqoen2kPjOkH2r4fxAj5gfV8Bg,1692
-fm_weck-1.4.6.dist-info/METADATA,sha256=lZPOGSSc4OeZvJ0m5VGGbo25DdX0twG-9rCEfYGE2A0,2822
-fm_weck-1.4.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fm_weck-1.4.6.dist-info/entry_points.txt,sha256=toWpKCSY1u593MPnI_xW5gnwlnkerP4AvmPQ1s2nPgY,50
-fm_weck-1.4.6.dist-info/RECORD,,
+fm_weck-1.4.7.dist-info/METADATA,sha256=WnQnKmjvJ6HQouE2-s1Mil4cw9NJW0Sp3d9E43upkhk,2822
+fm_weck-1.4.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fm_weck-1.4.7.dist-info/entry_points.txt,sha256=toWpKCSY1u593MPnI_xW5gnwlnkerP4AvmPQ1s2nPgY,50
+fm_weck-1.4.7.dist-info/RECORD,,