fm-weck 1.4.5__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.5"
+__version__ = "1.4.7"

fm_weck/__main__.py

@@ -4,6 +4,7 @@
 # SPDX-FileCopyrightText: 2024 Dirk Beyer <https://www.sosy-lab.org>
 #
 # SPDX-License-Identifier: Apache-2.0
+# PYTHON_ARGCOMPLETE_OK
 
 import sys
 

fm_weck/cache_mgr.py

@@ -0,0 +1,47 @@
+# This file is part of fm-weck: executing fm-tools in containerized environments.
+# https://gitlab.com/sosy-lab/software/fm-weck
+#
+# SPDX-FileCopyrightText: 2024 Dirk Beyer <https://www.sosy-lab.org>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import os
+import shutil
+
+logger = logging.getLogger(__name__)
+
+
+def ask_and_clear(cache_location: str):
+    response = (
+        input(f"The following cache location will be deleted: {cache_location}\nDo you want to proceed? (Y/n): ")
+        .strip()
+        .lower()
+    )
+
+    if response == "y":
+        clear_cache(cache_location)
+    elif response == "n":
+        return
+    else:
+        logger.error(f"Unknown command '{response}'\n")
+        ask_and_clear(cache_location)
+
+
+def clear_cache(cache_location: str):
+    if not cache_location:
+        logger.error("Cache location is unknown.")
+        return
+
+    if os.path.isdir(cache_location):
+        for item in os.listdir(cache_location):
+            item_path = os.path.join(cache_location, item)
+            try:
+                if os.path.isdir(item_path):
+                    shutil.rmtree(item_path)
+                else:
+                    os.remove(item_path)
+            except Exception as e:
+                logger.error(f"Error removing {item_path}: {e}")
+    else:
+        logger.error(f"The path {cache_location} is not a valid directory.")

fm_weck/cli.py

@@ -5,6 +5,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+
 import argparse
 import logging
 import os
@@ -12,26 +13,31 @@ 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
 
 from fm_weck import Config
+from fm_weck.cache_mgr import ask_and_clear, clear_cache
 from fm_weck.config import _SEARCH_ORDER
 from fm_weck.resources import iter_fm_data, iter_properties
 
@@ -61,7 +67,49 @@ class ToolQualifier:
             return
 
 
-def add_tool_arg(parser, nargs="?"):
+class ShellCompletion:
+    @staticmethod
+    def properties_completer(prefix, parsed_args, **kwargs):
+        return list_known_properties()
+
+    @staticmethod
+    def versions_completer(prefix, parsed_args, **kwargs):
+        return list_known_tools()
+
+    @staticmethod
+    def tool_completer(prefix, parsed_args, **kwargs):
+        try:
+            import yaml
+        except ImportError:
+            logger.error("PyYAML is not installed. Cannot complete tool names.")
+            return []
+
+        tools_and_versions: dict[str, list] = {}
+
+        for tool_path in iter_fm_data():
+            with open(tool_path) as stream:
+                tool_data = yaml.safe_load(stream)
+
+                try:
+                    versions = [version_data["version"] for version_data in tool_data["versions"]]
+                except KeyError:
+                    continue
+                tools_and_versions[tool_data["name"]] = versions
+
+        tools_and_versions_list = [
+            f"{tool.lower()}:{version}" for tool, versions in tools_and_versions.items() for version in versions
+        ]
+
+        selected_tools = set([tool.split(":")[0] for tool in tools_and_versions_list if tool.startswith(prefix)])
+        if len(selected_tools) == 1:
+            # If exactly one tool has been selected, suggest versions
+            return [tool for tool in tools_and_versions_list if tool.startswith(prefix)]
+
+        # If no tool has been selected, suggest tool names
+        return selected_tools
+
+
+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>. "
@@ -69,14 +117,15 @@ def add_tool_arg(parser, nargs="?"):
         "the path to a fm-tools yaml file.",
         type=ToolQualifier,
         nargs=nargs,
-    )
+    ).completer = ShellCompletion.tool_completer
 
 
 def add_shared_args_for_run_modes(parser):
     parser.add_argument(
-        "--skip-download",
+        "--offline",
         action="store_true",
-        help="Do not download the fm-tool, even if it is not available in the cache.",
+        help="Run the tools offline. The offline mode assumes that both the tool and its info-module are located "
+        "at the location specified by the config's 'cache_location' field.",
     )
 
     add_tool_arg(parser, nargs=None)
@@ -149,7 +198,7 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         ),
         required=False,
         default=None,
-    )
+    ).completer = ShellCompletion.properties_completer  # type: ignore[assignment]
 
     run.add_argument(
         "-d",
@@ -178,7 +227,7 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         "argument_list",
         metavar="args",
         nargs="*",
-        help="Additional arguments for the fm-tool." " To add them, separate them with '--' from the files.",
+        help="Additional arguments for the fm-tool. To add them, separate them with '--' from the files.",
     )
     run.set_defaults(main=main_run)
 
@@ -248,6 +297,32 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
     runexec.add_argument("argument_list", metavar="args", nargs="*", help="Arguments for runexec.")
     runexec.set_defaults(main=main_runexec)
 
+    clear_cache = subparsers.add_parser("clear-cache", help="Clear the cache directory.")
+    clear_cache.add_argument(
+        "--yes",
+        "-y",
+        "-Y",
+        action="store_true",
+        help="Add automatic approval for clearing the cache.",
+        required=False,
+        default=False,
+    )
+    clear_cache.set_defaults(main=main_clear_cache)
+
+    versions = subparsers.add_parser("versions", help="Show the versions of the chosen tool(s).")
+    versions.add_argument(
+        "TOOL",
+        help="The tool(s) for which to print the versions.",
+        type=ToolQualifier,
+        nargs="+",
+    ).completer = ShellCompletion.versions_completer  # type: ignore[assignment]
+    versions.set_defaults(main=main_versions)
+
+    with contextlib.suppress(ImportError):
+        import argcomplete
+
+        argcomplete.autocomplete(parser)
+
     def help_callback():
         parser.print_help()
 
@@ -295,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:
@@ -333,22 +408,25 @@ def main_run(args: argparse.Namespace):
         logger.error("Unknown property %s", args.property)
         return 1
 
-    return run_guided(
+    result = run_guided(
         fm_tool=fm_data,
         version=args.TOOL.version,
         configuration=Config(),
         prop=property_path,
+        witness=Path(args.witness) if args.witness else None,
         program_files=args.files,
         additional_args=args.argument_list,
         data_model=args.data_model,
-        skip_download=args.skip_download,
+        offline_mode=args.offline,
     )
 
+    return result.exit_code
+
 
 def main_runexec(args: argparse.Namespace):
     from .runexec_mode import run_runexec
 
-    return run_runexec(
+    result = run_runexec(
         benchexec_package=args.benchexec_package,
         use_image=args.use_image,
         configuration=Config(),
@@ -356,6 +434,8 @@ def main_runexec(args: argparse.Namespace):
         command=args.argument_list,
     )
 
+    return result.exit_code
+
 
 def main_manual(args: argparse.Namespace):
     from .serve import run_manual
@@ -369,20 +449,19 @@ def main_manual(args: argparse.Namespace):
         logger.error("Unknown tool %s", args.TOOL)
         return 1
 
-    return run_manual(
+    result = run_manual(
         fm_tool=fm_data,
         version=args.TOOL.version,
         configuration=Config(),
         command=args.argument_list,
-        skip_download=args.skip_download,
+        offline_mode=args.offline,
     )
 
+    return result.exit_code
 
-def main_install(args: argparse.Namespace):
-    from .serve import setup_fm_tool
 
-    if args.destination:
-        Config()._config["defaults"]["cache_location"] = args.destination.resolve()
+def main_install(args: argparse.Namespace):
+    from .serve import install_fm_tool
 
     for tool in args.TOOL:
         try:
@@ -391,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
@@ -413,7 +493,35 @@ def main_shell(args: argparse.Namespace):
             return 1
         engine = Engine.from_config(fm_data, args.TOOL.version, Config())
     engine.interactive = True
-    return engine.run(args.entry)
+    result = engine.run(args.entry)
+    return result.exit_code
+
+
+def main_clear_cache(args: argparse.Namespace):
+    if args.yes:
+        clear_cache(Config().get("defaults", {}).get("cache_location"))  # type: ignore
+    else:
+        ask_and_clear(Config().get("defaults", {}).get("cache_location"))  # type: ignore
+    return
+
+
+def main_versions(args: argparse.Namespace):
+    from .version_listing import VersionListing
+
+    tools = args.TOOL
+    tool_paths = []
+    if not args.TOOL:
+        logger.error("No fm-tool given. Aborting...")
+        return 1
+
+    for tool in tools:
+        try:
+            tool_paths.append(resolve_tool(tool))
+        except KeyError:
+            logger.error("Unknown tool %s", tool)
+            return 1
+
+    VersionListing(tool_paths).print_versions()
 
 
 def log_no_image_error(tool, config):
@@ -462,6 +570,7 @@ to your .fm-weck file.
 def cli(raw_args: list[str]):
     help_callback, args = parse(raw_args)
     configuration = Config().load(args.config)
+
     set_log_options(args.loglevel, args.logfile, configuration)
     if args.dry_run:
         Config().set_dry_run(True)

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)