fm-weck 1.4.6__py3-none-any.whl → 1.4.8__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.8"

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,11 +470,7 @@ def main_install(args: argparse.Namespace):
             logger.error("Unknown tool %s. Skipping installation...", tool)
             continue
 
-        setup_fm_tool(
-            fm_tool=fm_data,
-            version=tool.version,
-            configuration=Config(),
-        )
+        install_fm_tool(fm_tool=fm_data, version=tool.version, configuration=Config(), install_path=args.destination)
 
     return 0
 
@@ -499,9 +494,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

@@ -8,34 +8,43 @@
 import importlib.resources as pkg_resources
 import logging
 import os
-import shutil
 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
 
+from .file_util import copy_ensuring_unix_line_endings
+
 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 +130,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 +168,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 +194,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
 
@@ -192,7 +207,7 @@ class Config(object):
             # Try to copy from package resources
             try:
                 with pkg_resources.path("fm_weck.resources", target_name) as source_path:
-                    shutil.copy(source_path, target)
+                    copy_ensuring_unix_line_endings(source_path, target)
             except FileNotFoundError:
                 logging.error(f"Resource {target_name} not found in package.")
                 return None
@@ -200,7 +215,7 @@ class Config(object):
             # Compare modification time if the file exists
             with pkg_resources.path("fm_weck.resources", target_name) as source_path:
                 if source_path.stat().st_mtime > target.stat().st_mtime:
-                    shutil.copy(source_path, target)
+                    copy_ensuring_unix_line_endings(source_path, target)
                 else:
                     logging.debug(f"Using existing {target_name} script")
                     return target
@@ -224,7 +239,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 +248,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

@@ -7,6 +7,7 @@
 
 import io
 import logging
+import platform
 import shutil
 import signal
 import subprocess
@@ -15,20 +16,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
@@ -68,8 +74,8 @@ class Engine(ABC):
         if self._tmp_output_dir.exists():
             shutil.rmtree(self._tmp_output_dir)
 
-    def get_workdir(self):
-        return Path(CWD_MOUNT_LOCATION)
+    def get_workdir(self) -> str:
+        return Path(CWD_MOUNT_LOCATION).as_posix()
 
     def set_output_log(self, output_log: Path):
         self.log_file = output_log
@@ -121,7 +127,7 @@ class Engine(ABC):
             "--entrypoint",
             '[""]',
             "-v",
-            f"{Path.cwd().absolute()}:{CWD_MOUNT_LOCATION}",
+            f"{Path.cwd().absolute()}:{self.get_workdir()}",
             "-v",
             f"{Config().cache_location}:{CACHE_MOUNT_LOCATION}",
             "-v",
@@ -157,7 +163,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 +186,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."""
 
@@ -198,9 +204,9 @@ class Engine(ABC):
                     return p
             mapped = _map_path(Path(p))
             if Path(p) == mapped:
-                return p
+                return Path(p).as_posix()
             else:
-                return mapped
+                return Path(mapped).as_posix()
 
         return tuple(map(_map_path, command))
 
@@ -218,11 +224,11 @@ 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):
-        engine = config.defaults().get("engine", "podman").lower()
+        engine = "docker" if platform.system() != "Linux" else config.defaults().get("engine", "podman").lower()
 
         if engine == "docker":
             return Docker
@@ -241,7 +247,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 +255,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 +287,8 @@ class Engine(ABC):
 
     class BuildCommand(ABC):
         build_args: List[str] = []
+        containerfile: Path
+        _engine: str
 
         @abstractmethod
         def __init__(self, containerfile: Path, **kwargs):
@@ -290,7 +298,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 +350,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 +371,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 +401,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/file_util.py

@@ -0,0 +1,23 @@
+# 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
+
+from pathlib import Path
+
+# replacement strings
+WINDOWS_LINE_ENDING = b"\r\n"
+UNIX_LINE_ENDING = b"\n"
+
+
+def copy_ensuring_unix_line_endings(src: Path, dst: Path) -> None:
+    with open(src, "rb") as src_file:
+        content = src_file.read()
+
+    # Windows ➡ Unix
+    content = content.replace(WINDOWS_LINE_ENDING, UNIX_LINE_ENDING)
+
+    with open(dst, "wb") as dst_file:
+        dst_file.write(content)

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,58 @@
+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:
+  - B
+  - DVE
+  - ETF
+  - Event-B
+  - MCRL
+  - MCRL2
+  - PNML
+  - Promela
+  - TLA+
+  - Z
+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_images: ["ubuntu:24.04"]
+
+competition_participations: []
+
+techniques: []
+
+frameworks_solvers: []
+
+literature:
+  - doi: 10.1007/978-3-662-46681-0_61
+    title: "LTSmin: High-Performance Language-Independent Model Checking"
+    year: 2015
+  - doi: 10.1007/978-3-642-20398-5_40
+    title: "Multi-Core LTSmin: Marrying Modularity and Scalability"
+    year: 2011
+  - doi: 10.1007/978-3-642-14295-6_31
+    title: "LTSmin: Distributed and Symbolic Reachability"
+    year: 2010
+

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,20 +6,23 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import dbm
+import json
 import logging
 import os
-import shutil
 import sys
 from pathlib import Path
-from typing import Optional, Tuple, Union
+from typing import Optional, Tuple, Union, cast
 
-from fm_tools import FmData
 from fm_tools.benchexec_helper import DataModel
+from fm_tools.files import unzip
+from fm_tools.fmtoolversion import FmToolVersion
 
 from fm_weck.run_result import RunResult
+from fm_weck.tmp_file import NTempFile
 
 from .config import Config, parse_fm_data
 from .engine import CACHE_MOUNT_LOCATION, Engine
+from .file_util import copy_ensuring_unix_line_endings
 
 logger = logging.getLogger(__name__)
 
@@ -60,14 +63,15 @@ 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
+    fm_data = cast(FmToolVersion, fm_data)
 
     shelve_space = configuration.get_shelve_space_for(fm_data)
     logger.debug("Using shelve space %s", shelve_space)
@@ -75,13 +79,58 @@ 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)
+        if sys.platform != "win32":
+            fm_data.download_and_install_into(shelve_space)
+            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)
+
+            # On Windows, we need to download the tool first and then unzip it
+            # This is because the unzip operation might fail due to a permission error
+        else:
+            dl_loc = NTempFile(f"{fm_data.get_tool_name_with_version()}-dl.zip")
+            fm_data.download_into(dl_loc.name)
+
+            success = False
+            last_error = None
+
+            logging.info("Unzipping downloaded archive...")
+
+            # On Windows, the unzip operation might fail due to a permission error.
+            # Retrying the operation a few times mitigates this issue.
+            for _ in range(100):
+                try:
+                    unzip(dl_loc.name, shelve_space)
+                    success = True
+                    break
+                except PermissionError as e:
+                    last_error = e
+                    continue
+
+            if not success:
+                logger.error("Failed to unzip downloaded archive")
+                raise last_error
+
+        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()
 
@@ -98,8 +147,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],
@@ -120,10 +179,10 @@ def run_guided(
             # copy the property to the weck_cache which should be mounted
             source_property_path = prop
             property_path = configuration.get_shelve_path_for_property(source_property_path)
-            shutil.copyfile(source_property_path, property_path)
+            copy_ensuring_unix_line_endings(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 +216,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 +228,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 +259,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/tmp_file.py

@@ -0,0 +1,61 @@
+# 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 contextlib
+import os
+from pathlib import Path
+from tempfile import mkdtemp
+
+
+class NTempFile:
+    """
+    Custom temporary file context manager.
+    It creates a temporary file and deletes it after the context manager is closed.
+    The file is not kept open in order to achieve compatibility with Windows.
+
+    Inspired by https://stackoverflow.com/a/63173312
+    """
+
+    def __init__(self, name, mode="wb"):
+        self.__tmp_dir = mkdtemp()
+        self.name = Path(self.__tmp_dir) / name
+        self._mode = mode
+        self._file = None
+
+    def __enter__(self):
+        """Enter the context manager and return the file object."""
+        self._file = open(self.name, self._mode)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context manager and clean up."""
+        if self._file is not None:
+            self._file.close()
+        self._cleanup()
+
+    def write(self, data):
+        """Write data to the temporary file."""
+        if self._file is None:
+            # If not in context manager, open the file temporarily
+            with open(self.name, self._mode) as f:
+                f.write(data)
+        else:
+            self._file.write(data)
+            self._file.flush()  # Ensure data is written immediately
+
+    def _cleanup(self):
+        """Clean up the temporary file and directory."""
+        with contextlib.suppress(OSError):
+            if self.name.exists():
+                os.unlink(self.name)
+        with contextlib.suppress(OSError):
+            if Path(self.__tmp_dir).exists():
+                os.rmdir(self.__tmp_dir)
+
+    def __del__(self):
+        """Cleanup when object is garbage collected."""
+        self._cleanup()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fm-weck
-Version: 1.4.6
+Version: 1.4.8
 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'
@@ -36,7 +36,7 @@ We provide a tutorial on how to use fm-weck [here](doc/Tutorial.md).
 
 ## Install dependencies
 
-`fm-weck` requires Python 3.10 or higher. `fm-weck` relies on an available Podman installation. To install Podman on Ubuntu, run the following command:
+`fm-weck` requires Python 3.10 or higher. `fm-weck` relies on an available Podman or Docker installation. To install Podman on Ubuntu, run the following command:
 
 ```
 sudo apt install podman
@@ -46,11 +46,11 @@ sudo apt install podman
 
 There are three modes of operation: `run`, `shell` and `expert`.
 
+- `run`: (**Recommended**) enables plug-and-play execution of formal methods tools: it 
+downloads and unpacks a tool from the fm-tools metadata file into a user-specified cache directory on the host system and then runs the tool in the containerized environment
 - `expert`: executes a tool in it's containerized environment specified through the
 corresponding fm-tools YAML file: All arguments are passed verbatim to the tool.
 - `shell`: enters an interactive shell inside of the container specified by the given tool
-- `run`: enables plug-and-play execution of formal methods tools: it 
-downloads and unpacks a tool from the fm-tools metadata file into a user-specified cache directory on the host system and then runs the tool in the containerized environment
 
 ## Development and Testing
 
@@ -63,4 +63,10 @@ In Linux this can be done by running the following command in the root directory
 
 ```
 ln -s $(pwd)/fm_tools/data $(pwd)/src/fm_weck/resources/fm_tools
-```
+```
+
+## Publications
+
+A paper about fm-weck has been accepted at the FM '24 conference.
+
+- [<img src="/doc/images/pdf.png" alt="PDF icon" width="32"/> FM-Weck: Containerized Execution of Formal-Methods Tools](https://link.springer.com/content/pdf/10.1007/978-3-031-71177-0_3.pdf), by Dirk Beyer and Henrik Wachowitz. Proc. FM. Springer (2024). [doi:10.1007/978-3-031-71177-0_3](https://doi.org/10.1007/978-3-031-71177-0_3)

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

@@ -1,20 +1,22 @@
-fm_weck/__init__.py,sha256=DV5C4Bm7M37AnsKAzMOPeyxn9kt_BMFQM69KKWhiOos,351
+fm_weck/__init__.py,sha256=hwPTOu20emETJm7zBfj7trYoLdZD-A_ZoL0mtmZcyLw,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=gWiFsbkCOWS6oXTr6srWza-qFrfpU_XR1P-MxHrCQuM,17136
+fm_weck/config.py,sha256=8XXlHbb9cW1N1jatNFY5AnaRdxsSz-ohCrqq5t90RAc,8099
+fm_weck/engine.py,sha256=zway0nC4piPohK3hoBYr9Sv3xAa32dLeuPSuOw1Wers,17376
 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/file_util.py,sha256=R9y6LUZCDNJR4j25_Q24lN_zhACnOjYP5BvcpYaQPiA,649
+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=mDaZ1BUKwUh_fPgGMR4LXrJ1c5GOmwwXbHbMllmJzi8,10608
+fm_weck/tmp_file.py,sha256=oJiE8VGTPxhl-bXdtbM8eNqQ4e9ECPG1jDmiboVDo_k,1956
 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 +48,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 +86,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 +103,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=WkQ5aP-p1yFP6XfRXJeb5ftcd7o_buvNjEKZRVr6mpM,1644
 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 +124,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 +150,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.8.dist-info/METADATA,sha256=gGPe1x8nywUCLB85Ldg2MTFg4j7gMU8LRPFarOjIQKo,3269
+fm_weck-1.4.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fm_weck-1.4.8.dist-info/entry_points.txt,sha256=toWpKCSY1u593MPnI_xW5gnwlnkerP4AvmPQ1s2nPgY,50
+fm_weck-1.4.8.dist-info/RECORD,,