fm-weck 1.5.0__py3-none-any.whl → 1.5.2__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.5.0"
+__version__ = "1.5.2"

fm_weck/cli.py

@@ -419,8 +419,8 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         "TOOL",
         help="The tool for which to run the smoke test.",
         type=ToolQualifier,
-        nargs=1,
-    ).completer = ShellCompletion.versions_completer
+    ).completer = ShellCompletion.versions_completer  # type: ignore[assignment]
+
     smoke_test.add_argument(
         "--gitlab-ci-mode",
         action="store_true",
@@ -428,6 +428,15 @@ def parse(raw_args: list[str]) -> Tuple[Callable[[], None], Namespace]:
         required=False,
         default=False,
     )
+    smoke_test.add_argument(
+        "--competition-year",
+        action="store",
+        type=int,
+        help="Automatically select the tool version used in the specified competition year (e.g., 2025). "
+        "Searches for SV-COMP or Test-Comp participation in that year.",
+        required=False,
+        default=None,
+    )
     smoke_test.set_defaults(main=main_smoke_test)
 
     with contextlib.suppress(ImportError):
@@ -483,6 +492,41 @@ def resolve_property_for_server(prop_name: str) -> Union[Path, str]:
     return prop_name
 
 
+def get_version_for_competition_year(tool_path: Path, year: int) -> Optional[str]:
+    """
+    Find the tool version used in a competition for the given year.
+    Searches for SV-COMP or Test-Comp participation entries.
+
+    Args:
+        tool_path: Path to the tool's YAML file
+        year: Competition year (e.g., 2025)
+
+    Returns:
+        Version string if found, None otherwise
+    """
+    import yaml
+
+    if not tool_path.exists() or not tool_path.is_file():
+        return None
+
+    with tool_path.open("r") as f:
+        data = yaml.safe_load(f)
+
+    competition_participations = data.get("competition_participations", [])
+
+    # Search for competition entries matching the year
+    for participation in competition_participations:
+        competition = participation.get("competition", "")
+        # Match "SV-COMP 2025", "Test-Comp 2025", etc.
+        if f"{year}" in competition and ("SV-COMP" in competition or "Test-Comp" in competition):
+            version = participation.get("tool_version")
+            if version:
+                logger.info("Found version '%s' for %s in %s", version, tool_path.stem, competition)
+                return version
+
+    return None
+
+
 def set_log_options(loglevel: Optional[str], logfile: Optional[str], config: dict[str, Any]):
     level = "WARNING"
     level = loglevel.upper() if loglevel else config.get("logging", {}).get("level", level)
@@ -681,36 +725,129 @@ def check_client_options(timelimit_arg, output_path=None):
     return timelimit, output_path
 
 
-def main_smoke_test(args: argparse.Namespace):
-    from .serve import setup_fm_tool
-    from .smoke_test_mode import run_smoke_test, run_smoke_test_gitlab_ci
-
-    try:
-        tool = resolve_tool(args.TOOL[0])
-    except KeyError:
-        logger.error("Unknown tool: %s", args.TOOL[0].tool)
-        return 1
-
-    fm_data, shelve_space = setup_fm_tool(
-        fm_tool=tool,
-        version=args.TOOL[0].version,
-        configuration=Config(),
+def _do_smoke_test_mode(fm_data, shelve_space, tool, gitlab_ci_mode) -> int:
+    from .smoke_test_mode import (
+        run_smoke_test,
+        run_smoke_test_gitlab_ci,
     )
 
-    if args.gitlab_ci_mode:
+    # GitLab CI mode installs packages directly and runs the script on the host
+    if gitlab_ci_mode:
         from subprocess import CalledProcessError
 
         try:
             run_smoke_test_gitlab_ci(fm_data, shelve_space)
+            return 0
         except CalledProcessError as e:
+            logger.error(
+                "Smoke test script failed in GitLab CI mode (exit code %d).\n- Tool: %s\n- Script directory: %s\n",
+                e.returncode,
+                tool.stem,
+                shelve_space,
+            )
             return e.returncode
 
-        return 0
+    # Containerized mode: run script inside the configured image
+    result = run_smoke_test(fm_data, shelve_space, Config())
+    if result.exit_code != 0:
+        # Print a concise but informative error for CI logs
+        output_lines = result.raw_output.splitlines()
+        tail = "\n".join(output_lines[-50:]) if output_lines else "<no output captured>"
+        logger.error(
+            "Smoke test failed (exit code %d).\n"
+            "- Tool: %s\n"
+            "- Tool cache dir (host): %s\n"
+            "- Script name: smoketest.sh or smoke_test.sh\n"
+            "Last 50 lines of output:\n%s",
+            result.exit_code,
+            tool.stem,
+            shelve_space,
+            tail,
+        )
+        return result.exit_code
+
+    return 0
+
+
+def main_smoke_test(args: argparse.Namespace):
+    from fm_tools.exceptions import DownloadUnsuccessfulException, UnsupportedDOIException
+
+    from .serve import setup_fm_tool
+    from .smoke_test_mode import (
+        NoSmokeTestFileError,
+        SmokeTestError,
+        SmokeTestFileIsEmptyError,
+        SmokeTestFileIsNotExecutableError,
+    )
+
+    try:
+        tool = resolve_tool(args.TOOL)
+    except KeyError:
+        logger.error("Unknown tool: %s", args.TOOL.tool)
+        return 1
+
+    # Handle --competition-year flag
+    version = args.TOOL.version
+    if args.competition_year:
+        if version:
+            logger.warning(
+                "Both explicit version '%s' and --competition-year %d specified. "
+                "Using competition year to determine version.",
+                version,
+                args.competition_year,
+            )
+        competition_version = get_version_for_competition_year(tool, args.competition_year)
+        if competition_version:
+            logger.info("Using version '%s' for competition year %d", competition_version, args.competition_year)
+            version = competition_version
+        else:
+            logger.error("No competition participation found for year %d in tool %s", args.competition_year, tool.stem)
+            return 1
+
+    try:
+        fm_data, shelve_space = setup_fm_tool(
+            fm_tool=tool,
+            version=version,
+            configuration=Config(),
+        )
+    except (DownloadUnsuccessfulException, UnsupportedDOIException) as e:
+        if "code: 504" in str(e).lower():
+            print(
+                "Failed to download the tool due to a timeout (504 Gateway Timeout). "
+                "This issue is likely caused by Zenodo. Retry by rerunning the smoke test.",
+            )
+        else:
+            print(f"There was an error while downloading and unpacking the tool:\n{e}")
 
     try:
-        run_smoke_test(fm_data, shelve_space, Config())
+        return _do_smoke_test_mode(fm_data, shelve_space, tool, args.gitlab_ci_mode)
+    except NoSmokeTestFileError as e:
+        print(
+            f"{e}\n"
+            "Expected a smoke test script named 'smoketest.sh' or 'smoke_test.sh' in the tool directory.\n"
+            "Action: Add a minimal script 'smoke_test.sh' to the root of the tool directory that exercises the tool.\n"
+            "The top level contents of the tool directory were:\n"
+            f"{os.linesep.join([str(p.name) for p in shelve_space.iterdir()])}",
+        )
+        return 1
+    except SmokeTestFileIsEmptyError as e:
+        print(
+            f"{e}\nAction: Populate the smoke test script with at least one command that validates basic startup.",
+        )
+        return 1
+    except SmokeTestFileIsNotExecutableError as e:
+        print(
+            f"{e}\nAction: Make the smoke test script executable. On linux, you can do this by running:\n"
+            f"  chmod +x {e.smoke_test_file}",
+        )
+        return 1
     except ValueError as e:
-        logger.error(e)
+        # e.g., invalid shelve space path, or other validation errors
+        print(f"Smoke test setup failed: {e}")
+        return 1
+    except SmokeTestError as e:
+        # Fallback for any other smoke-test specific errors
+        print(f"Error starting the smoke test: {e}")
         return 1
 
 

fm_weck/config.py

@@ -135,6 +135,7 @@ class Config(object):
             """Makes sure relative Paths in the config are relative to the config file."""
 
             path = fn(self, *args, **kwargs)
+            path = path.expanduser()
 
             if not self._config_source:
                 return path

fm_weck/engine.py

@@ -66,7 +66,7 @@ class Engine(ABC):
     overlay_tool_dir: Optional[str] = None
     image: Optional[str] = None
     dry_run: bool = False
-    work_dir: Optional[Path] = Path(CWD_MOUNT_LOCATION)
+    work_dir: Path = Path(CWD_MOUNT_LOCATION)
 
     def __init__(self, image: Union[str, FmImageConfig]):
         self._tmp_output_dir = Path(mkdtemp("fm_weck_output")).resolve()
@@ -84,7 +84,7 @@ class Engine(ABC):
             shutil.rmtree(self._tmp_output_dir)
 
     def get_workdir(self) -> str:
-        return Path(CWD_MOUNT_LOCATION).as_posix()
+        return self.work_dir.as_posix()
 
     def set_log_file(self, log_file: Path):
         self.log_file = log_file
@@ -142,7 +142,7 @@ class Engine(ABC):
             "--entrypoint",
             '[""]',
             "-v",
-            f"{Path.cwd().absolute()}:{self.get_workdir()}",
+            f"{Path.cwd().absolute()}:{Path(CWD_MOUNT_LOCATION).as_posix()}",
             "-v",
             f"{Config().cache_location}:{CACHE_MOUNT_LOCATION}",
             "-v",

fm_weck/smoke_test_mode.py

@@ -6,6 +6,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+import os
 import subprocess
 from pathlib import Path
 
@@ -16,6 +17,67 @@ from .engine import CACHE_MOUNT_LOCATION, Engine
 logger = logging.getLogger(__name__)
 
 
+class SmokeTestError(Exception):
+    """Custom exception for smoke test errors."""
+
+    pass
+
+
+class NoSmokeTestFileError(SmokeTestError):
+    """Exception raised when no smoke test file is found."""
+
+    pass
+
+
+class SmokeTestFileIsEmptyError(SmokeTestError):
+    """Exception raised when the smoke test file is empty."""
+
+    pass
+
+
+class SmokeTestFileIsNotExecutableError(SmokeTestError):
+    """Exception raised when the smoke test file is not executable."""
+
+    smoke_test_file: Path
+
+    def __init__(self, smoke_test_file: Path):
+        self.smoke_test_file = smoke_test_file
+        super().__init__(f"Smoke test file is not executable: {smoke_test_file}")
+
+    pass
+
+
+def locate_and_check_smoke_test_file(shelve_space: Path) -> str:
+    """Check if the smoke test file exists and is not empty.
+
+    Args:
+        shelve_space: Path to the shelve space directory.
+
+    Returns:
+        The relative path to the smoke test file as a string.
+
+    Raises:
+        NoSmokeTestFileError: If the smoke test file does not exist.
+        SmokeTestFileIsEmptyError: If the smoke test file is empty.
+    """
+    if not (shelve_space / "smoketest.sh").exists() and not (shelve_space / "smoke_test.sh").exists():
+        raise NoSmokeTestFileError(f"Smoke test file not found in: {shelve_space}")
+
+    if (shelve_space / "smoketest.sh").exists():
+        file_path = shelve_space / "smoketest.sh"
+    else:
+        # Since we checked for existence above, this must exist
+        file_path = shelve_space / "smoke_test.sh"
+
+    if not file_path.stat().st_mode & os.X_OK:
+        raise SmokeTestFileIsNotExecutableError(file_path.relative_to(shelve_space))
+
+    if file_path.stat().st_size == 0:
+        raise SmokeTestFileIsEmptyError(f"Smoke test file is empty: {file_path}")
+
+    return f"./{file_path.name}"
+
+
 def run_smoke_test(fm_data, shelve_space, config):
     if not shelve_space.exists() or not shelve_space.is_dir():
         raise ValueError(f"Invalid shelve space path: {shelve_space}")
@@ -25,15 +87,10 @@ def run_smoke_test(fm_data, shelve_space, config):
     tool_dir = shelve_space.relative_to(config.cache_location)
     engine.work_dir = CACHE_MOUNT_LOCATION / tool_dir
 
-    # Check for smoketest.sh first, then smoke_test.sh
-    if (shelve_space / "smoketest.sh").exists():
-        command = "./smoketest.sh"
-    elif (shelve_space / "smoke_test.sh").exists():
-        command = "./smoke_test.sh"
-    else:
-        raise ValueError(f"Smoke test script not found in {shelve_space}. Expected ./smoketest.sh or ./smoke_test.sh")
+    command = locate_and_check_smoke_test_file(shelve_space)
 
-    engine.run(command)
+    # Return the result so callers can react to failures and print diagnostics
+    return engine.run(command)
 
 
 def run_smoke_test_gitlab_ci(fm_data: FmToolVersion, tool_dir: Path):
@@ -61,21 +118,11 @@ def run_smoke_test_gitlab_ci(fm_data: FmToolVersion, tool_dir: Path):
     else:
         logger.info("No required packages specified for this tool")
 
-    # Run the smoke test script
-    # Check for smoketest.sh first, then smoke_test.sh
-    smoke_test_script = tool_dir / "smoketest.sh"
-    if not smoke_test_script.exists():
-        smoke_test_script = tool_dir / "smoke_test.sh"
-
-    if not smoke_test_script.exists():
-        raise ValueError(
-            f"Smoke test script not found in downloaded tool directory: {tool_dir}. "
-            f"Expected ./smoketest.sh or ./smoke_test.sh"
-        )
+    script_command = locate_and_check_smoke_test_file(tool_dir)
 
-    logger.info("Running smoke test script: %s", smoke_test_script)
+    logger.info("Running smoke test script: %s", script_command)
     try:
-        subprocess.run([f"./{smoke_test_script.name}"], cwd=tool_dir, check=True)
+        subprocess.run([script_command], cwd=tool_dir, check=True)
         logger.info("Smoke test completed successfully")
     except subprocess.CalledProcessError as e:
         logger.error("Smoke test failed with return code %d", e.returncode)

{fm_weck-1.5.0.dist-info → fm_weck-1.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fm-weck
-Version: 1.5.0
+Version: 1.5.2
 Author-email: Henrik Wachowitz <henrik.wachowitz@ifi.lmu.de>
 Maintainer-email: Henrik Wachowitz <henrik.wachowitz@ifi.lmu.de>
 Classifier: Development Status :: 4 - Beta

{fm_weck-1.5.0.dist-info → fm_weck-1.5.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
-fm_weck/__init__.py,sha256=v0ltYQ0MeG-hs4LVU6TIPeboGSEmIMSDHqOGvQdQR_s,351
+fm_weck/__init__.py,sha256=P8xygPjF_sqOcyrYtuILR2BsTY8VZAPkvhl0WRrgKSc,351
 fm_weck/__main__.py,sha256=IfNDAqM6MK6P7KsQoW3wOHPOscB8evdVlS9C7R4wd_0,391
 fm_weck/cache_mgr.py,sha256=3-OQFmCeswazXmX08ND4oEHFOR07ZDCwWzjmFTDkOSE,1373
 fm_weck/capture.py,sha256=iogn3JvCZEjD0SQL8Xa3TzmZAWifd9ZIP81c3JIsdUQ,982
-fm_weck/cli.py,sha256=dPpJqyF0iXqZuRiPATypDbc6TyaUWzUFpb1qc2uo-mg,23657
-fm_weck/config.py,sha256=8XXlHbb9cW1N1jatNFY5AnaRdxsSz-ohCrqq5t90RAc,8099
-fm_weck/engine.py,sha256=HfRj5Okewteco7A-CccCIbk2aEGDh4K896YyQo7h1gE,21733
+fm_weck/cli.py,sha256=wDRzNUvocQmBKicP7aeJPWLmiIlHd_nnH87vEowMNk4,29097
+fm_weck/config.py,sha256=DHIdGA4OhVAHAPJyB--G19EwGshAirmb6PGwoJQtZaE,8136
+fm_weck/engine.py,sha256=P48zCTeMHI3imE0ho5AxhDNTRY3mX0Nzd0gBzjqRCX4,21729
 fm_weck/exceptions.py,sha256=AfqTt6gxZPUQ0rKqwgdGTyfIjWmU3xBFIJxQnMLbLGo,2465
 fm_weck/file_util.py,sha256=FG_uBuNWGWbSivBv0dYzwugMkGfdS_iFY-hG6GLDD54,799
 fm_weck/image_mgr.py,sha256=lkn1nWuwKtMhtVf_PFZOOJftY5uyE0EydY2f-sefHGE,1943
@@ -12,7 +12,7 @@ fm_weck/run_result.py,sha256=srg3w2MvC-2YqgpRtqrat2DoxhErtlc5FQO3uaFaGTI,1253
 fm_weck/runexec_mode.py,sha256=UamxVvYm0XErPjR2sRJaLMX8uHBzRcgCTWbQIZjdju0,2195
 fm_weck/runexec_util.py,sha256=YBvVIPpmEousZVxbZ5NS8jzpKPLyws31kIFE2z3Ki2E,1370
 fm_weck/serve.py,sha256=RUz_3v15By_CvcBJlNBw-mKuDubAiIha5EfayFBnqps,10728
-fm_weck/smoke_test_mode.py,sha256=SYXLf1mhdGEOS9YtJ7XuR8j_zfN9zUWhu1KSm4zgAR4,2990
+fm_weck/smoke_test_mode.py,sha256=5n2LdYyTxATFl-yaDVfkie-IiNACL3Hs2c_CARqMvek,4196
 fm_weck/tmp_file.py,sha256=oJiE8VGTPxhl-bXdtbM8eNqQ4e9ECPG1jDmiboVDo_k,1956
 fm_weck/version_listing.py,sha256=caaoC3n9R-Ao2sEQ_ngOVO3bnKr7cNVeH6EiA8jO5Sc,864
 fm_weck/grpc_service/__init__.py,sha256=TvQSR0pVeh4MMMT40VfzJFyZTHpAOI7C808vjJpWiOs,390
@@ -165,7 +165,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.5.0.dist-info/METADATA,sha256=UqR47gDzSfO-MS7U0lEmpMoYJ5Xe6Vx_4cxMXg7qq-0,3339
-fm_weck-1.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fm_weck-1.5.0.dist-info/entry_points.txt,sha256=toWpKCSY1u593MPnI_xW5gnwlnkerP4AvmPQ1s2nPgY,50
-fm_weck-1.5.0.dist-info/RECORD,,
+fm_weck-1.5.2.dist-info/METADATA,sha256=1a0oYolO5XlQSwC0tT2qWCdzzroGb-PdS6YQbFEZUME,3339
+fm_weck-1.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fm_weck-1.5.2.dist-info/entry_points.txt,sha256=toWpKCSY1u593MPnI_xW5gnwlnkerP4AvmPQ1s2nPgY,50
+fm_weck-1.5.2.dist-info/RECORD,,