fm-weck 1.4.8__py3-none-any.whl → 1.5.0__py3-none-any.whl

fm_weck/grpc_service/fm_weck_client.py

@@ -0,0 +1,148 @@
+# 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
+from typing import Tuple
+
+import grpc
+
+from .proto.fm_weck_service_pb2 import (
+    CancelRunRequest,
+    ExpertRunRequest,
+    FileQuery,
+    Property,
+    RunID,
+    RunRequest,
+    ToolType,
+    WaitParameters,
+)
+from .proto.fm_weck_service_pb2_grpc import FmWeckRemoteStub
+
+
+def start_run(stub, tool, prop, c_program):
+    with open(tool[0], "rb") as tool_file, open(prop, "rb") as property_file:
+        tool_bin = tool_file.read()
+        prop_bin = property_file.read()
+
+    tool_data: ToolType = ToolType(tool_version=tool[1], tool_file={"name": "fm-tool.yml", "file": tool_bin})
+    prop_data: Property = Property(property_file={"name": "property.prp", "file": prop_bin})
+    run_info = RunRequest(tool=tool_data, property=prop_data, c_program=c_program, data_model="ILP32")
+    run_id = stub.startRun(run_info)
+
+    return run_id
+
+
+def start_expert_run(stub, tool, command):
+    with open(tool[0], "rb") as tool_file:
+        tool_bin = tool_file.read()
+
+    tool_data: ToolType = ToolType(tool_version=tool[1], tool_file={"name": "fm-tool.yml", "file": tool_bin})
+    expert_run_info = ExpertRunRequest(tool=tool_data, command=command)
+    run_id = stub.startExpertRun(expert_run_info)
+
+    return run_id
+
+
+def cancel_run(stub, run_id, confirmed=True):
+    if confirmed:
+        stub.cancelRun(CancelRunRequest(run_id=run_id, timeout=5, cleanup_on_success=True))
+
+
+def wait_on_run(stub, run_id, timelimit):
+    response = stub.waitOnRun(WaitParameters(run_id=run_id, timeout=timelimit))
+
+    if not response:
+        print("Server timed out or returned no files.")
+        exit(1)
+
+    if response.error:
+        print(response.error, ": Error occurred on the server side.")
+        exit(response.error)
+    elif response.timeout:
+        print("Run timed out.")
+        exit(1)
+
+    if not response.run_result.success:
+        print("There was an error running the tool.")
+        exit(1)
+
+    print()
+    print(response.run_result.output)
+    if response.run_result.filenames:
+        print("The run produced the following files:")
+        print(response.run_result.filenames)
+        print(
+            "\nFiles can be obtained by running:\nfm-weck query-files [-h] --host HOST [--timelimit TIMELIMIT]"
+            "[--output-path OUTPUT_PATH] RUN-ID [files ...]"
+        )
+    else:
+        print("The run produced no files.")
+    print()
+
+    return response
+
+
+def query_files(host: str, run_id: str, file_names: str, timelimit: int, output_path: Path):
+    print("Establishing a connection to the server ...")
+    with grpc.insecure_channel(host) as channel:
+        stub = FmWeckRemoteStub(channel)
+
+        run_id = RunID(run_id=run_id)
+        try:
+            wait_on_run(stub, run_id, timelimit)
+        except KeyboardInterrupt:
+            cancel_run(stub, run_id)
+
+        request = FileQuery(filenames=file_names, run_id=run_id)
+        responses = stub.queryFiles(request)
+
+        output_path = output_path / "fm_weck_server_files" / run_id.run_id
+        output_path.mkdir(exist_ok=True, parents=True)
+        for response in responses:
+            with open(output_path / response.name, "wb") as output_file:
+                output_file.write(response.file)
+
+
+def client_run(tool: Tuple[Path, str], host: str, prop: Path, files: list[Path], timelimit: int):
+    with open(files[0], "rb") as c_file:
+        c_program = c_file.read()
+
+    print("Establishing a connection to the server ...")
+    with grpc.insecure_channel(host) as channel:
+        stub = FmWeckRemoteStub(channel)
+
+        run_id = start_run(stub, tool, prop, c_program)
+        print("Run ID: ", run_id.run_id)
+        try:
+            wait_on_run(stub, run_id, timelimit)
+        except KeyboardInterrupt:
+            cancel_run(stub, run_id)
+
+
+def client_expert_run(tool: Tuple[Path, str], host: str, command: list[str], timelimit: int):
+    print("Establishing a connection to the server ...")
+    with grpc.insecure_channel(host) as channel:
+        stub = FmWeckRemoteStub(channel)
+
+        run_id = start_expert_run(stub, tool, command)
+        print("Run ID: ", run_id.run_id)
+        try:
+            wait_on_run(stub, run_id, timelimit)
+        except KeyboardInterrupt:
+            cancel_run(stub, run_id)
+
+
+def client_get_run(host: str, run_id: str, timelimit: int):
+    print("Establishing a connection to the server ...")
+    with grpc.insecure_channel(host) as channel:
+        stub = FmWeckRemoteStub(channel)
+
+        run_id = RunID(run_id=run_id)
+        try:
+            wait_on_run(stub, run_id, timelimit)
+        except KeyboardInterrupt:
+            cancel_run(stub, run_id)

fm_weck/grpc_service/fm_weck_server.py

@@ -0,0 +1,175 @@
+# 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 concurrent import futures
+from pathlib import Path
+from typing import Generator
+
+import grpc
+
+from fm_weck.exceptions import failure_to_error_code
+
+from . import run_store as RunStore
+from .proto.fm_weck_service_pb2 import (
+    CancelRunRequest,
+    CancelRunResult,
+    CleanUpResponse,
+    ErrorCode,
+    ExpertRunRequest,
+    File,
+    FileQuery,
+    RunID,
+    RunRequest,
+    RunResult,
+    WaitParameters,
+    WaitRunResult,
+)
+from .proto.fm_weck_service_pb2_grpc import FmWeckRemoteServicer, add_FmWeckRemoteServicer_to_server
+from .request_handling import RunHandler, StillRunningError
+from .server_utils import (
+    logger,
+    read_file,
+)
+
+
+class FmWeckRemote(FmWeckRemoteServicer):
+    def startRun(self, request: RunRequest, context) -> RunID:
+        run_handler = RunHandler(request)
+        run_handler.start()
+
+        run_id = RunStore.add_run(run_handler)
+
+        return RunID(run_id=run_id)
+
+    def startExpertRun(self, request: ExpertRunRequest, context) -> RunID:
+        run_handler = RunHandler(request)
+        run_handler.start_expert(request.command)
+
+        run_id = RunStore.add_run(run_handler)
+
+        return RunID(run_id=run_id)
+
+    def cancelRun(self, request: CancelRunRequest, context) -> CancelRunResult:
+        run_handler = RunStore.get_run(request.run_id.run_id)
+
+        if not run_handler:
+            return CancelRunResult(error=ErrorCode.EC_RUN_NOT_FOUND)
+
+        if run_handler.is_running():
+            run_handler.cancel_run()
+            # Wait a short amount of time. For most cases, the run should be canceled by now.
+            try:
+                run_handler.join(request.timeout)
+            except TimeoutError:
+                return CancelRunResult(timeout=True)
+
+        if request.cleanup_on_success:
+            run_handler.cleanup()
+
+        return CancelRunResult(run_result=self._run_result_from_handler(run_handler))
+
+    def waitOnRun(self, request: WaitParameters, context) -> WaitRunResult:
+        logger.info("waitOnRun called for run_id=%s, timeout=%s", request.run_id.run_id, request.timeout)
+        run_handler = RunStore.get_run(request.run_id.run_id)
+
+        if run_handler is None:
+            logger.info("waitOnRun: run not found (run_id=%s)", request.run_id.run_id)
+            return WaitRunResult(error=ErrorCode.EC_RUN_NOT_FOUND)
+
+        try:
+            run_handler.join(request.timeout)
+        except TimeoutError:
+            logger.info("waitOnRun: timeout (run_id=%s)", request.run_id.run_id)
+            return WaitRunResult(timeout=True)
+
+        if run_handler.ready() and not run_handler._success:
+            failure = run_handler.failure()
+            error_code = failure_to_error_code(failure) if failure else ErrorCode.EC_UNKNOWN_ERROR
+            logger.info("waitOnRun: failed (run_id=%s)", request.run_id.run_id)
+            return WaitRunResult(error=error_code)
+
+        logger.info("waitOnRun: success (run_id=%s)", request.run_id.run_id)
+        return WaitRunResult(run_result=self._run_result_from_handler(run_handler))
+
+    def queryFiles(self, query: FileQuery, context) -> Generator[File, None, None]:
+        run_handler = RunStore.get_run(query.run_id.run_id)
+        if run_handler is None:
+            return
+
+        filenames_to_consider = query.filenames or []
+        name_patterns_to_consider = query.name_patterns or []
+
+        for file_name in filenames_to_consider:
+            try:
+                file = run_handler.get_file(file_name)
+                yield self._file_from_path(file)
+            except FileNotFoundError:
+                continue
+
+        for name_pattern in name_patterns_to_consider:
+            for file in run_handler.glob(name_pattern):
+                yield self._file_from_path(file)
+
+        # The empty query returns all files.
+        if len(filenames_to_consider) == 0 and len(name_patterns_to_consider) == 0:
+            files_generator = self._all_files_from_path(run_handler._output_dir)
+            for file in files_generator:
+                yield file
+
+    def cleanupRun(self, request: RunID, context):
+        run_handler = RunStore.get_run(request.run_id)
+
+        if run_handler is None:
+            return CleanUpResponse(success=False, error=ErrorCode.EC_RUN_NOT_FOUND)
+
+        try:
+            run_handler.cleanup()
+        except StillRunningError:
+            return CleanUpResponse(success=False, error=ErrorCode.EC_RUN_NOT_TERMINATED)
+
+        RunStore.remove_run(request.run_id)
+
+        return CleanUpResponse(success=True)
+
+    @staticmethod
+    def _file_from_path(file_path: str | Path) -> File:
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+
+        return File(name=file_path.name, file=read_file(file_path))
+
+    @staticmethod
+    def _all_files_from_path(directory_path: str | Path):
+        if isinstance(directory_path, str):
+            directory_path = Path(directory_path)
+
+        for file_path in directory_path.rglob("*"):
+            if file_path.is_file():
+                yield FmWeckRemote._file_from_path(file_path)
+
+    @staticmethod
+    def _run_result_from_handler(run_handler: RunHandler) -> RunResult:
+        return RunResult(
+            run_id=RunID(run_id=run_handler.run_id),
+            success=run_handler.ready() and run_handler.successful(),
+            output=run_handler.output,
+            filenames=run_handler.output_files,
+        )
+
+
+def serve(ipaddr: str, port: str):
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+    add_FmWeckRemoteServicer_to_server(FmWeckRemote(), server)
+    server.add_insecure_port(f"{ipaddr}:{port}")
+    server.start()
+    logger.info("Server started, listening on " + port)
+    try:
+        server.wait_for_termination()
+    except KeyboardInterrupt:
+        logger.info("Shutting down the server...")
+        server.stop(grace=0)
+        logger.info("Server successfully shut down.")

fm_weck/grpc_service/proto/fm_weck_service.proto

@@ -0,0 +1,139 @@
+// 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
+
+syntax = "proto3";
+
+// This service runs fm-weck remotely.
+
+service FmWeckRemote {
+    // Runs a verification task for a given C program.
+    rpc startRun(RunRequest) returns (RunID) {}
+
+    // Runs a tool in expert mode
+    rpc startExpertRun(ExpertRunRequest) returns (RunID) {}
+
+    // Cancels a previously started run.
+    rpc cancelRun(CancelRunRequest) returns (CancelRunResult) {}
+
+    // Cleans up files of a finished run.
+    rpc cleanupRun(RunID) returns (CleanUpResponse) {}
+
+    // Gets the result of a previously started run using its unique ID.
+    rpc waitOnRun(WaitParameters) returns (WaitRunResult) {}
+
+    // Query for a number of result files.
+    rpc queryFiles(FileQuery) returns (stream File) {}
+}
+
+message ToolType {
+  optional string tool_version = 1;
+  oneof tool_data {
+    File tool_file = 2;
+    string tool_id = 3;
+  }
+}
+
+message Property {
+  oneof property {
+    string property_id = 1;
+    File property_file = 2;
+  }
+}
+
+message RunRequest {
+  ToolType tool = 1;
+  Property property = 2;
+  bytes c_program = 4;
+  string data_model = 5;
+}
+
+message ExpertRunRequest{
+  ToolType tool = 1;
+  repeated string command = 2;
+  }
+
+message RunResult {
+  RunID run_id = 1;
+  // Whether the run was successful or terminated with an error
+  bool success = 2;
+  // The output produced by fm-weck
+  string output = 3;
+  // List of files produced by the run; may be empty
+  repeated string filenames = 4;
+}
+
+message WaitRunResult {
+  // Whether the request has timed out or not
+  oneof result {
+    bool timeout = 1;
+    ErrorCode error = 2;
+    RunResult run_result = 3;
+  }
+}
+
+message CancelRunRequest {
+  RunID run_id = 1;
+  // Timeout in seconds to wait for completion of the cancellation
+  uint32 timeout = 2;
+  // If true, the run is cleaned up on the server side
+  optional bool cleanup_on_success = 3;
+}
+
+message CancelRunResult {
+  oneof result {
+    // Whether the could be canceled completely
+    // or is still shutting down. 
+    // If True, then the run is canceled on the server side, but complete shutdown may take some time.
+    // Call waitOnRun if the termination must be confirmed.
+    bool timeout = 1;
+    ErrorCode error = 2;
+    RunResult run_result = 3;
+  }
+}
+
+enum ErrorCode {
+  // The run is not terminated yet
+  EC_RUN_NOT_TERMINATED = 0;
+  EC_RUN_NOT_FOUND = 1;
+  EC_RUN_CANCELLED = 2;
+  EC_RUN_FAILED = 3;
+  EC_UNKNOWN_ERROR = 4;
+}
+
+message CleanUpResponse {
+  // If cleanup was successful, this field is true
+  // Then no errors are reported.
+  bool success = 1;
+  // If success is false, this field contains the error code
+  optional ErrorCode error = 2;
+}
+
+message RunID {
+  string run_id = 1;
+}
+
+message WaitParameters {
+  //Timeout in seconds to wait for the run to finish
+  uint32 timeout = 1;
+  RunID run_id = 2;
+}
+
+message FileQuery {
+  // If the run_id does not exist, the server will return an empty stream.
+  RunID run_id = 3;
+  
+  // Non existent files are ignored.
+  repeated string filenames = 1;
+  repeated string name_patterns = 2;
+}
+
+message File {
+  string name = 1;
+  bytes file = 2;
+}
+
+message Empty {}

fm_weck/grpc_service/proto/fm_weck_service_pb2.py

@@ -0,0 +1,73 @@
+# 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
+
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: fm_weck_service.proto
+# Protobuf Python Version: 5.29.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'fm_weck_service.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x66m_weck_service.proto\"r\n\x08ToolType\x12\x19\n\x0ctool_version\x18\x01 \x01(\tH\x01\x88\x01\x01\x12\x1a\n\ttool_file\x18\x02 \x01(\x0b\x32\x05.FileH\x00\x12\x11\n\x07tool_id\x18\x03 \x01(\tH\x00\x42\x0b\n\ttool_dataB\x0f\n\r_tool_version\"M\n\x08Property\x12\x15\n\x0bproperty_id\x18\x01 \x01(\tH\x00\x12\x1e\n\rproperty_file\x18\x02 \x01(\x0b\x32\x05.FileH\x00\x42\n\n\x08property\"i\n\nRunRequest\x12\x17\n\x04tool\x18\x01 \x01(\x0b\x32\t.ToolType\x12\x1b\n\x08property\x18\x02 \x01(\x0b\x32\t.Property\x12\x11\n\tc_program\x18\x04 \x01(\x0c\x12\x12\n\ndata_model\x18\x05 \x01(\t\"<\n\x10\x45xpertRunRequest\x12\x17\n\x04tool\x18\x01 \x01(\x0b\x32\t.ToolType\x12\x0f\n\x07\x63ommand\x18\x02 \x03(\t\"W\n\tRunResult\x12\x16\n\x06run_id\x18\x01 \x01(\x0b\x32\x06.RunID\x12\x0f\n\x07success\x18\x02 \x01(\x08\x12\x0e\n\x06output\x18\x03 \x01(\t\x12\x11\n\tfilenames\x18\x04 \x03(\t\"k\n\rWaitRunResult\x12\x11\n\x07timeout\x18\x01 \x01(\x08H\x00\x12\x1b\n\x05\x65rror\x18\x02 \x01(\x0e\x32\n.ErrorCodeH\x00\x12 \n\nrun_result\x18\x03 \x01(\x0b\x32\n.RunResultH\x00\x42\x08\n\x06result\"s\n\x10\x43\x61ncelRunRequest\x12\x16\n\x06run_id\x18\x01 \x01(\x0b\x32\x06.RunID\x12\x0f\n\x07timeout\x18\x02 \x01(\r\x12\x1f\n\x12\x63leanup_on_success\x18\x03 \x01(\x08H\x00\x88\x01\x01\x42\x15\n\x13_cleanup_on_success\"m\n\x0f\x43\x61ncelRunResult\x12\x11\n\x07timeout\x18\x01 \x01(\x08H\x00\x12\x1b\n\x05\x65rror\x18\x02 \x01(\x0e\x32\n.ErrorCodeH\x00\x12 \n\nrun_result\x18\x03 \x01(\x0b\x32\n.RunResultH\x00\x42\x08\n\x06result\"L\n\x0f\x43leanUpResponse\x12\x0f\n\x07success\x18\x01 \x01(\x08\x12\x1e\n\x05\x65rror\x18\x02 \x01(\x0e\x32\n.ErrorCodeH\x00\x88\x01\x01\x42\x08\n\x06_error\"\x17\n\x05RunID\x12\x0e\n\x06run_id\x18\x01 \x01(\t\"9\n\x0eWaitParameters\x12\x0f\n\x07timeout\x18\x01 \x01(\r\x12\x16\n\x06run_id\x18\x02 \x01(\x0b\x32\x06.RunID\"M\n\tFileQuery\x12\x16\n\x06run_id\x18\x03 \x01(\x0b\x32\x06.RunID\x12\x11\n\tfilenames\x18\x01 \x03(\t\x12\x15\n\rname_patterns\x18\x02 \x03(\t\"\"\n\x04\x46ile\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04\x66ile\x18\x02 \x01(\x0c\"\x07\n\x05\x45mpty*{\n\tErrorCode\x12\x19\n\x15\x45\x43_RUN_NOT_TERMINATED\x10\x00\x12\x14\n\x10\x45\x43_RUN_NOT_FOUND\x10\x01\x12\x14\n\x10\x45\x43_RUN_CANCELLED\x10\x02\x12\x11\n\rEC_RUN_FAILED\x10\x03\x12\x14\n\x10\x45\x43_UNKNOWN_ERROR\x10\x04\x32\x93\x02\n\x0c\x46mWeckRemote\x12!\n\x08startRun\x12\x0b.RunRequest\x1a\x06.RunID\"\x00\x12-\n\x0estartExpertRun\x12\x11.ExpertRunRequest\x1a\x06.RunID\"\x00\x12\x32\n\tcancelRun\x12\x11.CancelRunRequest\x1a\x10.CancelRunResult\"\x00\x12(\n\ncleanupRun\x12\x06.RunID\x1a\x10.CleanUpResponse\"\x00\x12.\n\twaitOnRun\x12\x0f.WaitParameters\x1a\x0e.WaitRunResult\"\x00\x12#\n\nqueryFiles\x12\n.FileQuery\x1a\x05.File\"\x00\x30\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'fm_weck_service_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_ERRORCODE']._serialized_start=1101
+  _globals['_ERRORCODE']._serialized_end=1224
+  _globals['_TOOLTYPE']._serialized_start=25
+  _globals['_TOOLTYPE']._serialized_end=139
+  _globals['_PROPERTY']._serialized_start=141
+  _globals['_PROPERTY']._serialized_end=218
+  _globals['_RUNREQUEST']._serialized_start=220
+  _globals['_RUNREQUEST']._serialized_end=325
+  _globals['_EXPERTRUNREQUEST']._serialized_start=327
+  _globals['_EXPERTRUNREQUEST']._serialized_end=387
+  _globals['_RUNRESULT']._serialized_start=389
+  _globals['_RUNRESULT']._serialized_end=476
+  _globals['_WAITRUNRESULT']._serialized_start=478
+  _globals['_WAITRUNRESULT']._serialized_end=585
+  _globals['_CANCELRUNREQUEST']._serialized_start=587
+  _globals['_CANCELRUNREQUEST']._serialized_end=702
+  _globals['_CANCELRUNRESULT']._serialized_start=704
+  _globals['_CANCELRUNRESULT']._serialized_end=813
+  _globals['_CLEANUPRESPONSE']._serialized_start=815
+  _globals['_CLEANUPRESPONSE']._serialized_end=891
+  _globals['_RUNID']._serialized_start=893
+  _globals['_RUNID']._serialized_end=916
+  _globals['_WAITPARAMETERS']._serialized_start=918
+  _globals['_WAITPARAMETERS']._serialized_end=975
+  _globals['_FILEQUERY']._serialized_start=977
+  _globals['_FILEQUERY']._serialized_end=1054
+  _globals['_FILE']._serialized_start=1056
+  _globals['_FILE']._serialized_end=1090
+  _globals['_EMPTY']._serialized_start=1092
+  _globals['_EMPTY']._serialized_end=1099
+  _globals['_FMWECKREMOTE']._serialized_start=1227
+  _globals['_FMWECKREMOTE']._serialized_end=1502
+# @@protoc_insertion_point(module_scope)

fm_weck/grpc_service/proto/fm_weck_service_pb2.pyi

@@ -0,0 +1,151 @@
+# 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 google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class ErrorCode(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    EC_RUN_NOT_TERMINATED: _ClassVar[ErrorCode]
+    EC_RUN_NOT_FOUND: _ClassVar[ErrorCode]
+    EC_RUN_CANCELLED: _ClassVar[ErrorCode]
+    EC_RUN_FAILED: _ClassVar[ErrorCode]
+    EC_UNKNOWN_ERROR: _ClassVar[ErrorCode]
+EC_RUN_NOT_TERMINATED: ErrorCode
+EC_RUN_NOT_FOUND: ErrorCode
+EC_RUN_CANCELLED: ErrorCode
+EC_RUN_FAILED: ErrorCode
+EC_UNKNOWN_ERROR: ErrorCode
+
+class ToolType(_message.Message):
+    __slots__ = ("tool_version", "tool_file", "tool_id")
+    TOOL_VERSION_FIELD_NUMBER: _ClassVar[int]
+    TOOL_FILE_FIELD_NUMBER: _ClassVar[int]
+    TOOL_ID_FIELD_NUMBER: _ClassVar[int]
+    tool_version: str
+    tool_file: File
+    tool_id: str
+    def __init__(self, tool_version: _Optional[str] = ..., tool_file: _Optional[_Union[File, _Mapping]] = ..., tool_id: _Optional[str] = ...) -> None: ...
+
+class Property(_message.Message):
+    __slots__ = ("property_id", "property_file")
+    PROPERTY_ID_FIELD_NUMBER: _ClassVar[int]
+    PROPERTY_FILE_FIELD_NUMBER: _ClassVar[int]
+    property_id: str
+    property_file: File
+    def __init__(self, property_id: _Optional[str] = ..., property_file: _Optional[_Union[File, _Mapping]] = ...) -> None: ...
+
+class RunRequest(_message.Message):
+    __slots__ = ("tool", "property", "c_program", "data_model")
+    TOOL_FIELD_NUMBER: _ClassVar[int]
+    PROPERTY_FIELD_NUMBER: _ClassVar[int]
+    C_PROGRAM_FIELD_NUMBER: _ClassVar[int]
+    DATA_MODEL_FIELD_NUMBER: _ClassVar[int]
+    tool: ToolType
+    property: Property
+    c_program: bytes
+    data_model: str
+    def __init__(self, tool: _Optional[_Union[ToolType, _Mapping]] = ..., property: _Optional[_Union[Property, _Mapping]] = ..., c_program: _Optional[bytes] = ..., data_model: _Optional[str] = ...) -> None: ...
+
+class ExpertRunRequest(_message.Message):
+    __slots__ = ("tool", "command")
+    TOOL_FIELD_NUMBER: _ClassVar[int]
+    COMMAND_FIELD_NUMBER: _ClassVar[int]
+    tool: ToolType
+    command: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, tool: _Optional[_Union[ToolType, _Mapping]] = ..., command: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class RunResult(_message.Message):
+    __slots__ = ("run_id", "success", "output", "filenames")
+    RUN_ID_FIELD_NUMBER: _ClassVar[int]
+    SUCCESS_FIELD_NUMBER: _ClassVar[int]
+    OUTPUT_FIELD_NUMBER: _ClassVar[int]
+    FILENAMES_FIELD_NUMBER: _ClassVar[int]
+    run_id: RunID
+    success: bool
+    output: str
+    filenames: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, run_id: _Optional[_Union[RunID, _Mapping]] = ..., success: bool = ..., output: _Optional[str] = ..., filenames: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class WaitRunResult(_message.Message):
+    __slots__ = ("timeout", "error", "run_result")
+    TIMEOUT_FIELD_NUMBER: _ClassVar[int]
+    ERROR_FIELD_NUMBER: _ClassVar[int]
+    RUN_RESULT_FIELD_NUMBER: _ClassVar[int]
+    timeout: bool
+    error: ErrorCode
+    run_result: RunResult
+    def __init__(self, timeout: bool = ..., error: _Optional[_Union[ErrorCode, str]] = ..., run_result: _Optional[_Union[RunResult, _Mapping]] = ...) -> None: ...
+
+class CancelRunRequest(_message.Message):
+    __slots__ = ("run_id", "timeout", "cleanup_on_success")
+    RUN_ID_FIELD_NUMBER: _ClassVar[int]
+    TIMEOUT_FIELD_NUMBER: _ClassVar[int]
+    CLEANUP_ON_SUCCESS_FIELD_NUMBER: _ClassVar[int]
+    run_id: RunID
+    timeout: int
+    cleanup_on_success: bool
+    def __init__(self, run_id: _Optional[_Union[RunID, _Mapping]] = ..., timeout: _Optional[int] = ..., cleanup_on_success: bool = ...) -> None: ...
+
+class CancelRunResult(_message.Message):
+    __slots__ = ("timeout", "error", "run_result")
+    TIMEOUT_FIELD_NUMBER: _ClassVar[int]
+    ERROR_FIELD_NUMBER: _ClassVar[int]
+    RUN_RESULT_FIELD_NUMBER: _ClassVar[int]
+    timeout: bool
+    error: ErrorCode
+    run_result: RunResult
+    def __init__(self, timeout: bool = ..., error: _Optional[_Union[ErrorCode, str]] = ..., run_result: _Optional[_Union[RunResult, _Mapping]] = ...) -> None: ...
+
+class CleanUpResponse(_message.Message):
+    __slots__ = ("success", "error")
+    SUCCESS_FIELD_NUMBER: _ClassVar[int]
+    ERROR_FIELD_NUMBER: _ClassVar[int]
+    success: bool
+    error: ErrorCode
+    def __init__(self, success: bool = ..., error: _Optional[_Union[ErrorCode, str]] = ...) -> None: ...
+
+class RunID(_message.Message):
+    __slots__ = ("run_id",)
+    RUN_ID_FIELD_NUMBER: _ClassVar[int]
+    run_id: str
+    def __init__(self, run_id: _Optional[str] = ...) -> None: ...
+
+class WaitParameters(_message.Message):
+    __slots__ = ("timeout", "run_id")
+    TIMEOUT_FIELD_NUMBER: _ClassVar[int]
+    RUN_ID_FIELD_NUMBER: _ClassVar[int]
+    timeout: int
+    run_id: RunID
+    def __init__(self, timeout: _Optional[int] = ..., run_id: _Optional[_Union[RunID, _Mapping]] = ...) -> None: ...
+
+class FileQuery(_message.Message):
+    __slots__ = ("run_id", "filenames", "name_patterns")
+    RUN_ID_FIELD_NUMBER: _ClassVar[int]
+    FILENAMES_FIELD_NUMBER: _ClassVar[int]
+    NAME_PATTERNS_FIELD_NUMBER: _ClassVar[int]
+    run_id: RunID
+    filenames: _containers.RepeatedScalarFieldContainer[str]
+    name_patterns: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, run_id: _Optional[_Union[RunID, _Mapping]] = ..., filenames: _Optional[_Iterable[str]] = ..., name_patterns: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class File(_message.Message):
+    __slots__ = ("name", "file")
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    FILE_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    file: bytes
+    def __init__(self, name: _Optional[str] = ..., file: _Optional[bytes] = ...) -> None: ...
+
+class Empty(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...