fm-weck 1.5.1__py3-none-any.whl → 1.5.3__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.1"
+__version__ = "1.5.3"

fm_weck/cli.py

@@ -581,6 +581,9 @@ def main_runexec(args: argparse.Namespace):
         command=args.argument_list,
     )
 
+    if result is None:
+        return 1  # Indicate failure due to runexec setup issues
+
     return result.exit_code
 
 
@@ -725,9 +728,60 @@ def check_client_options(timelimit_arg, output_path=None):
     return timelimit, output_path
 
 
+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,
+    )
+
+    # 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
+
+    # 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\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 run_smoke_test, run_smoke_test_gitlab_ci
+    from .smoke_test_mode import (
+        NoSmokeTestFileError,
+        SmokeTestError,
+        SmokeTestFileIsEmptyError,
+        SmokeTestFileIsNotExecutableError,
+    )
 
     try:
         tool = resolve_tool(args.TOOL)
@@ -753,26 +807,50 @@ def main_smoke_test(args: argparse.Namespace):
             logger.error("No competition participation found for year %d in tool %s", args.competition_year, tool.stem)
             return 1
 
-    fm_data, shelve_space = setup_fm_tool(
-        fm_tool=tool,
-        version=version,
-        configuration=Config(),
-    )
-
-    if args.gitlab_ci_mode:
-        from subprocess import CalledProcessError
-
-        try:
-            run_smoke_test_gitlab_ci(fm_data, shelve_space)
-        except CalledProcessError as e:
-            return e.returncode
-
-        return 0
+    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' in the tool directory.\n"
+            "Action: Add a minimal script 'smoketest.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

@@ -14,8 +14,6 @@ from functools import cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, Tuple, TypeVar
 
-from werkzeug.utils import secure_filename
-
 try:
     from fm_tools.fmtool import FmTool
     from fm_tools.fmtoolversion import FmToolVersion
@@ -37,7 +35,7 @@ except ImportError:
                 raise ImportError("fm_tools is not imported.")
 
 
-from fm_weck.resources import RUN_WITH_OVERLAY, RUNEXEC_SCRIPT
+from fm_weck.resources import RUN_WITH_OVERLAY
 
 from .file_util import copy_ensuring_unix_line_endings
 
@@ -135,6 +133,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
@@ -169,6 +168,8 @@ class Config(object):
         return self.cache_location / ".checksums.dbm"
 
     def get_shelve_space_for(self, fm_data: FmToolVersion) -> Path:
+        from werkzeug.utils import secure_filename
+
         shelve = self.cache_location
         # Remove leading http:// or https:// from the raw archive location
         raw_location = fm_data.get_archive_location().raw
@@ -194,9 +195,6 @@ 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 | None:
-        return self.make_script_available(RUNEXEC_SCRIPT)
-
     def make_script_available(self, target_name: str = RUN_WITH_OVERLAY) -> Path | None:
         script_dir = self.cache_location / ".scripts"
         target = script_dir / target_name

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/resources/__init__.py

@@ -9,8 +9,6 @@ import importlib.resources as pkg_resources
 from functools import cache
 from pathlib import Path
 
-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
 
@@ -20,7 +18,8 @@ RUNEXEC_SCRIPT = "runexec"
 
 
 def iter_fm_data():
-    for entry in pkg_resources.files(fm_tools).iterdir():
+    root = pkg_resources.files(__package__) / "fm_tools"
+    for entry in root.iterdir():
         if entry.name.endswith((".yml", ".yaml")):
             with pkg_resources.as_file(entry) as path:
                 fm_data_path = Path(path)
@@ -29,7 +28,8 @@ def iter_fm_data():
 
 
 def iter_properties():
-    for entry in pkg_resources.files(properties).iterdir():
+    root = pkg_resources.files(__package__) / "properties"
+    for entry in root.iterdir():
         with pkg_resources.as_file(entry) as path:
             prop_path = Path(path)
             if prop_path.is_file():

fm_weck/run_result.py

@@ -6,12 +6,11 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from dataclasses import dataclass
-from functools import singledispatchmethod
+from typing import TYPE_CHECKING
 
-from benchexec.tools.template import BaseTool2
-from benchexec.util import ProcessExitCode
-from fm_tools.fmtoolversion import FmToolVersion
-from fm_tools.run import get_tool_info
+if TYPE_CHECKING:
+    from benchexec.tools.template import BaseTool2
+    from fm_tools.fmtoolversion import FmToolVersion
 
 
 @dataclass(frozen=True)
@@ -21,6 +20,9 @@ class RunResult:
     raw_output: str
 
     def as_benchexec_run(self):
+        from benchexec.tools.template import BaseTool2
+        from benchexec.util import ProcessExitCode
+
         return BaseTool2.Run(
             cmdline=self.command,
             exit_code=ProcessExitCode.create(value=self.exit_code),
@@ -28,11 +30,13 @@ class RunResult:
             termination_reason=False,  # TODO: We do not know about this
         )
 
-    @singledispatchmethod
-    def determine_result(self, tool: BaseTool2) -> str:
-        return tool.determine_result(self.as_benchexec_run())
+    def determine_result(self, tool: "BaseTool2 | FmToolVersion") -> str:
+        from benchexec.tools.template import BaseTool2
+
+        if isinstance(tool, BaseTool2):
+            return tool.determine_result(self.as_benchexec_run())
+
+        from fm_tools.run import get_tool_info
 
-    @determine_result.register
-    def _(self, tool: FmToolVersion) -> str:
         tool_ = get_tool_info(tool)
-        return self.determine_result(tool_)
+        return tool_.determine_result(self.as_benchexec_run())

fm_weck/runexec_mode.py

@@ -7,11 +7,13 @@
 
 import importlib.resources as pkg_resources
 import logging
+import os
 import shutil
 from pathlib import Path
+from tempfile import NamedTemporaryFile
 from typing import TYPE_CHECKING, Optional
 
-from fm_weck.resources import BENCHEXEC_WHL
+from fm_weck.resources import BENCHEXEC_WHL, RUNEXEC_SCRIPT
 from fm_weck.runexec_util import mountable_absolute_paths_of_command
 
 from .config import Config
@@ -20,16 +22,38 @@ from .engine import CACHE_MOUNT_LOCATION, Engine
 logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
+    from tempfile import _TemporaryFileWrapper
+
     from fm_weck.run_result import RunResult
 
 
+def _setup_script_in_cache(target: "_TemporaryFileWrapper[bytes]") -> Path:
+    # When running multiple instances in parallel it can happen, that two processes interfere
+    # when copying the script causing a "Text file is busy" error.
+    # Using a temp file avoids this problem.
+    # The cleaner solution would be to use a direct bind mount from the package resource, but this does not
+    # work on the benchcloud right now.
+
+    with pkg_resources.path("fm_weck.resources", RUNEXEC_SCRIPT) as source_path:
+        shutil.copy(source_path, target.name)
+
+    target_path = Path(target.name)
+    mode = target_path.stat().st_mode
+    # make the temp file executable
+    target_path.chmod(mode | os.X_OK)
+    target.flush()
+    target.close()
+
+    return target_path
+
+
 def run_runexec(
     benchexec_package: Optional[Path],
     use_image: Optional[str],
     configuration: Config,
     extra_container_args: list[list[str]],
     command: list[str],
-) -> "RunResult":
+) -> "RunResult| None":
     if use_image is not None:
         configuration.set_default_image(use_image)
 
@@ -38,7 +62,7 @@ def run_runexec(
     engine.add_mounting_capabilities = False
 
     if benchexec_package is not None:
-        engine.mount(benchexec_package.parent.absolute(), "/home/__fm_weck_benchexec")
+        engine.mount(str(benchexec_package.parent.absolute()), "/home/__fm_weck_benchexec")
         engine.env["PYTHONPATH"] = f"/home/__fm_weck_benchexec/{benchexec_package.name}"
     else:
         # Default to the bundled benchexec package
@@ -52,13 +76,19 @@ def run_runexec(
             return None
 
     for path in mountable_absolute_paths_of_command(Path.cwd().absolute(), command):
-        engine.mount(path, str(path) + ":ro")
+        engine.mount(str(path), str(path) + ":ro")
 
     for arg in extra_container_args:
         engine.add_container_long_opt(arg)
 
-    configuration.make_runexec_script_available()
-
     engine.handle_io = False
 
-    return engine.run(f"{CACHE_MOUNT_LOCATION}/.scripts/runexec", *command)
+    with (
+        NamedTemporaryFile(
+            prefix="runexec_", dir=str(configuration.cache_location / ".scripts"), delete=True, delete_on_close=False
+        ) as tmp_file,
+    ):
+        script_path = _setup_script_in_cache(tmp_file)
+
+        rel_path = script_path.relative_to(configuration.cache_location)
+        return engine.run(f"{CACHE_MOUNT_LOCATION}/{rel_path}", *command)

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,63 @@ 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, is executable, 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.
+        SmokeTestFileIsNotExecutableError: If the smoke test file is not executable.
+    """
+    file_path = shelve_space / "smoketest.sh"
+    if not file_path.exists():
+        raise NoSmokeTestFileError(f"Smoke test file 'smoketest.sh' not found in: {shelve_space}")
+
+    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 +83,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):
@@ -43,7 +96,7 @@ def run_smoke_test_gitlab_ci(fm_data: FmToolVersion, tool_dir: Path):
 
     Args:
         fm_data: The FmToolVersion object containing tool information
-        tool_dir: The directory containing the tool's smoke_test.sh script
+        tool_dir: The directory containing the tool's smoketest.sh script
     """
     # Get required packages from fm_data
     required_packages = fm_data.get_images().required_packages
@@ -61,21 +114,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.1.dist-info → fm_weck-1.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fm-weck
-Version: 1.5.1
+Version: 1.5.3
 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.1.dist-info → fm_weck-1.5.3.dist-info}/RECORD

@@ -1,18 +1,18 @@
-fm_weck/__init__.py,sha256=pcp30MR-tRkciy0U5U7dBSMuP9rJ3Vwv4O5spbrdbmA,351
+fm_weck/__init__.py,sha256=XKFqL4QIrZPlt9h9GadbHOpCIMJiY650ZjDdLbYQWa8,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=9Foecc_r5-sZIzBgo0d0kOmZhP0dMGfTwCRh6j0rLAE,25977
-fm_weck/config.py,sha256=8XXlHbb9cW1N1jatNFY5AnaRdxsSz-ohCrqq5t90RAc,8099
-fm_weck/engine.py,sha256=HfRj5Okewteco7A-CccCIbk2aEGDh4K896YyQo7h1gE,21733
+fm_weck/cli.py,sha256=sY9MYVqma0b7abXyqoLZ2rh0JkP6y72WUayble_cPVY,29149
+fm_weck/config.py,sha256=N7PgJRHXrhwNbfussz7NTGGMAVaFy9YiUbYFIXlRzVE,8009
+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
-fm_weck/run_result.py,sha256=srg3w2MvC-2YqgpRtqrat2DoxhErtlc5FQO3uaFaGTI,1253
-fm_weck/runexec_mode.py,sha256=UamxVvYm0XErPjR2sRJaLMX8uHBzRcgCTWbQIZjdju0,2195
+fm_weck/run_result.py,sha256=58SIkYpdZY3l5A7UKk4Uz2V8W57uo_nfKQPZD3V4-Iw,1377
+fm_weck/runexec_mode.py,sha256=ws1FwQxLFumh8iklFXeFRMgWXRLSWNX2eUlh-QcMqo8,3359
 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=FAUftedyDl_-xxsU74CcX4RxYH_cPR0zsNkIZwkk2Os,4060
 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
@@ -30,7 +30,7 @@ fm_weck/grpc_service/proto/generate_protocol_files.sh,sha256=F9dd95qKejtB7B3P-x9
 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=HpPkrzJe1IKsmLOfbe5LbT-suaV6eJn1fT4csSvEkOk,390
-fm_weck/resources/__init__.py,sha256=Gd3SNYBUUgDCJFMVwaaPynmugTUKoWamBXRhbasRKJE,1522
+fm_weck/resources/__init__.py,sha256=c3WqvUoTCFCM1SVxYEDQs4FqFxcNRiJkpeN5g-OA5VU,1550
 fm_weck/resources/c_program_example.c,sha256=WOTAn4XyQL8TlplI6M8FbKiUxiwnvHUy2o6n0hLIe6o,21862
 fm_weck/resources/run_with_overlay.sh,sha256=v1gV_6kMQ0v9BQ3chgDqI1MAOLHbPWeeTC52aCqVpEM,1162
 fm_weck/resources/runexec,sha256=ogIBO38HLu9C9kDTTANBgAqVnH-UIF1bSJ9d3DSjyF4,462
@@ -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.1.dist-info/METADATA,sha256=jYdZSrXwB_PzT8dVahhwa76YCuFXSPUe5MfB0bHrAYI,3339
-fm_weck-1.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fm_weck-1.5.1.dist-info/entry_points.txt,sha256=toWpKCSY1u593MPnI_xW5gnwlnkerP4AvmPQ1s2nPgY,50
-fm_weck-1.5.1.dist-info/RECORD,,
+fm_weck-1.5.3.dist-info/METADATA,sha256=m_4VrPdPCvQesR-70_0l0y_wSZf1fROQ01QOoZFpUKo,3339
+fm_weck-1.5.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fm_weck-1.5.3.dist-info/entry_points.txt,sha256=toWpKCSY1u593MPnI_xW5gnwlnkerP4AvmPQ1s2nPgY,50
+fm_weck-1.5.3.dist-info/RECORD,,