remote-exec-grpc 0.2.1__py3-none-any.whl

remote_exec/__init__.py

@@ -0,0 +1,10 @@
+"""Remote command execution over gRPC."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+# Single source of truth: the version in pyproject.toml (via installed metadata),
+# shared by remote-exec-server, remote-exec-client and the GetServerInfo RPC.
+try:
+    __version__ = version("remote-exec-grpc")
+except PackageNotFoundError:  # running from a source tree without installation
+    __version__ = "0.0.0+unknown"

remote_exec/claude_skill.md

@@ -0,0 +1,118 @@
+---
+description: Run commands on remote Linux servers that have specialised tools or hardware (FPGA tools, GPUs, licensed software, datasets) using remote-exec-client. Use when a task needs a tool or resource that is not available locally but exists on a configured remote server.
+argument-hint: "[task or SERVER COMMAND]"
+---
+
+# Remote execution with `remote-exec-client`
+
+`remote-exec-client` runs a shell command on a remote server and streams the
+remote **stdout and stderr live**, like `ssh SERVER COMMAND`. Its exit status is
+the remote command's exit status, so judge success exactly as for a local
+command. You only ever need `remote-exec-client`; the servers are already set
+up and running.
+
+If this was invoked with arguments, the request is: $ARGUMENTS
+
+## 1. Find out which servers exist
+
+```bash
+remote-exec-client --list            # NAME  HOST:PORT  description (tools/resources)
+remote-exec-client SERVER --ping     # reachable? remote host/user, allowed and denied programs
+```
+
+Each server may restrict which programs commands can run (its `tools.yaml`).
+`--ping` shows the allowed and denied program lists; by default everything
+except `ssh` is allowed. Plan commands that only use allowed programs.
+
+Pick the server whose description lists the tool or resource you need. If
+none fits or the description is unclear, check with a harmless probe such as
+`remote-exec-client SERVER "command -v vivado nvcc python3; nvidia-smi -L"`,
+or ask the user. Do not guess server names that `--list` does not show.
+
+## 2. When to run remotely
+
+- The task needs a tool that is not installed locally (e.g. `vivado`, `vsim`,
+  `nvcc`, `nvidia-smi`) and a server provides it.
+- The task needs remote hardware (GPU, FPGA board), licenses, or data that live
+  on a server.
+- Do **not** use it for things that work locally (editing files, local `git`,
+  reading code). A server sees only its own filesystem: project files must
+  already exist there (git checkout, NFS, shared directory). If local changes
+  are needed remotely, sync them first (e.g. commit/push, then `git pull`
+  remotely) and tell the user you did so.
+
+## 3. Usage
+
+```bash
+remote-exec-client SERVER [options] "COMMAND"
+```
+
+- Pass the command as **one quoted argument**. It runs as `bash -c "COMMAND"`
+  on the server, so pipes, `&&`, globs and `$VARS` are evaluated remotely. Use
+  single quotes locally when `$VAR` must not expand on your machine.
+- `--cwd DIR` sets the remote working directory (absolute, or `'~/path'`).
+  Prefer it over `cd DIR && ...`.
+- `-e KEY=VALUE` sets a remote environment variable (repeatable); `-e KEY`
+  copies the local value.
+- `--timeout SECONDS` kills the remote command **and all its child processes**
+  when exceeded. Always set one, sized to the job (e.g. `120` for a quick test,
+  `7200` for a full FPGA implementation run).
+- `--verbose` prints a summary line (host, status, exit code, duration) to stderr.
+- stdin is not forwarded: commands must be non-interactive.
+- Programs that buffer output when not on a TTY (e.g. Python) stream better
+  with `-e PYTHONUNBUFFERED=1` or `python -u`.
+
+Examples:
+
+```bash
+remote-exec-client gpu01 --timeout 30 "nvidia-smi"
+remote-exec-client fpga01 --cwd /home/user/project --timeout 7200 \
+    "vivado -mode batch -source build.tcl"
+remote-exec-client fpga01 --cwd /home/user/project \
+    -e FPGA_PART=xcvu37p -e BUILD_MODE=release --timeout 3600 "./build.sh"
+remote-exec-client gpu01 --cwd '~/ml' -e PYTHONUNBUFFERED=1 --timeout 600 \
+    "python train.py --epochs 1"
+```
+
+## 4. Interpreting the result
+
+| exit status | meaning |
+|-------------|---------|
+| `0` | remote command succeeded |
+| other `1..123`, `125..127` | remote command failed with that status; `127` = command not found on that server (wrong server or PATH) |
+| `124` | `--timeout` exceeded; the remote process tree was killed. Output so far was printed. Increase the timeout only if the job was making progress |
+| `126` | the server's tools policy blocked a program in the command; nothing was run. The message names the program |
+| `128+N` | remote command killed by signal N (`137` = SIGKILL, often out of memory) |
+| `130` / `143` | the client itself was interrupted; the remote command was cancelled |
+| `255` | remote-exec problem, not the command: unreachable server, authentication failure, bad config, invalid `--cwd`. Read the message on stderr |
+
+Lines starting with `remote-exec-client:` on stderr come from the client;
+all other output comes from the remote command.
+
+## 5. Long-running jobs and large output
+
+- Keep output small: filter **remotely** inside the quoted command, e.g.
+  `"make 2>&1 | tail -n 100"`, or write the full log to a remote file and
+  inspect it with follow-up commands:
+  `"vivado -mode batch -source build.tcl > build.log 2>&1; echo exit=$?; tail -n 100 build.log"`.
+- If your own tool call has a time limit shorter than the job, set the remote
+  `--timeout` below it so the remote side is cleaned up deterministically.
+  For jobs longer than that, start them with output redirected to a log file
+  and a generous `--timeout`, run the call in the background, and check
+  progress with separate commands (`tail -n 50 build.log`).
+- Interrupting or killing the client terminates the remote command.
+
+## 6. Safety
+
+- Commands run with the remote service user's permissions on shared machines.
+  Do not run destructive commands (`rm -rf`, `git reset --hard`, `git clean`,
+  killing other users' processes, editing system files, rebooting, flashing
+  hardware) unless the user explicitly asked for exactly that. When in doubt,
+  ask first.
+- Inspect before changing anything (`ls`, `cat`, `git status`).
+- If a command is blocked by the server's tools policy (exit `126`), do not
+  try to work around it (wrappers, scripts, `python -c`, variables). The
+  restriction is deliberate: use an allowed alternative or ask the user. Do not
+  `ssh` from a remote server to other machines.
+- Never put secrets (tokens, license keys, passwords) in commands or `-e`
+  values: command lines are recorded in the server's audit log.

remote_exec/client.py

@@ -0,0 +1,242 @@
+"""Async gRPC client library (no CLI concerns).
+
+Typical use::
+
+    async with RemoteExecClient(endpoint) as client:
+        result = await client.run("make test", on_stdout=..., on_stderr=...)
+        print(result.exit_code)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from collections.abc import AsyncIterator, Callable, Mapping
+from dataclasses import dataclass
+from datetime import datetime
+
+import grpc
+
+from .config import TOKEN_ENV_VAR, ServerEndpoint
+from .security import auth_metadata, channel_credentials, read_secret_file
+from .v1 import remote_exec_pb2 as pb
+from .v1 import remote_exec_pb2_grpc as pb_grpc
+
+DEFAULT_CONNECT_TIMEOUT = 10.0
+
+# Shell/ssh-like exit codes for outcomes that are not a remote exit status.
+EXIT_TIMEOUT = 124      # same as coreutils `timeout`
+EXIT_REJECTED = 126     # same as the shell's "cannot execute": blocked by the server's tools policy
+EXIT_INTERRUPTED = 130  # 128 + SIGINT
+EXIT_CLIENT_ERROR = 255  # same as ssh: connection/auth/protocol failure
+
+CLIENT_OPTIONS = [
+    ("grpc.keepalive_time_ms", 30_000),
+    ("grpc.keepalive_timeout_ms", 20_000),
+    ("grpc.keepalive_permit_without_calls", 1),
+    ("grpc.http2.max_pings_without_data", 0),
+    ("grpc.max_receive_message_length", 16 * 1024 * 1024),
+]
+
+
+class RemoteExecError(Exception):
+    """Failure of the remote execution machinery (not of the remote command)."""
+
+
+class ServerUnavailable(RemoteExecError):
+    pass
+
+
+class CommandRejected(RemoteExecError):
+    """The server refused to run the command (tools policy)."""
+
+
+@dataclass
+class ExecutionResult:
+    status: str  # "exited" | "timeout" | "error"
+    exit_code: int
+    signal: int
+    message: str
+    execution_id: str
+    hostname: str
+    start_time: datetime | None
+    end_time: datetime | None
+
+    @property
+    def ok(self) -> bool:
+        return self.status == "exited" and self.exit_code == 0
+
+    @property
+    def duration(self) -> float | None:
+        if self.start_time and self.end_time:
+            return (self.end_time - self.start_time).total_seconds()
+        return None
+
+    @property
+    def local_exit_code(self) -> int:
+        """Exit code a CLI wrapper should return for this result."""
+        if self.status == "exited":
+            return self.exit_code
+        if self.status == "timeout":
+            return EXIT_TIMEOUT
+        return EXIT_CLIENT_ERROR
+
+
+_STATUS_NAMES = {
+    pb.Finished.EXITED: "exited",
+    pb.Finished.TIMEOUT: "timeout",
+    pb.Finished.ERROR: "error",
+}
+
+
+def resolve_token(endpoint: ServerEndpoint) -> str | None:
+    if endpoint.token:
+        return endpoint.token
+    if endpoint.token_file:
+        return read_secret_file(endpoint.token_file)
+    return os.environ.get(TOKEN_ENV_VAR) or None
+
+
+def _describe_rpc_error(endpoint: ServerEndpoint, err: grpc.aio.AioRpcError) -> str:
+    code = err.code()
+    details = err.details() or ""
+    where = f"{endpoint.name} ({endpoint.address})" if endpoint.name != endpoint.address else endpoint.address
+    if code == grpc.StatusCode.UNAVAILABLE:
+        return f"cannot reach server {where}: {details}"
+    if code == grpc.StatusCode.UNAUTHENTICATED:
+        return f"authentication failed for {where}: {details}"
+    if code == grpc.StatusCode.PERMISSION_DENIED:
+        return f"{where} refused to run the command: {details}"
+    if code == grpc.StatusCode.INVALID_ARGUMENT:
+        return f"invalid request: {details}"
+    if code == grpc.StatusCode.RESOURCE_EXHAUSTED:
+        return f"server {where} is busy: {details}"
+    if code == grpc.StatusCode.CANCELLED:
+        return f"call to {where} was cancelled: {details}"
+    return f"{where}: {code.name}: {details}"
+
+
+class RemoteExecClient:
+    def __init__(self, endpoint: ServerEndpoint, connect_timeout: float | None = None):
+        self.endpoint = endpoint
+        self.connect_timeout = connect_timeout or endpoint.connect_timeout or DEFAULT_CONNECT_TIMEOUT
+        self._metadata = auth_metadata(resolve_token(endpoint))
+        self._channel: grpc.aio.Channel | None = None
+        self._stub: pb_grpc.RemoteExecutorStub | None = None
+
+    def _make_channel(self) -> grpc.aio.Channel:
+        ep = self.endpoint
+        options = list(CLIENT_OPTIONS)
+        if ep.uses_tls:
+            if ep.tls_server_name:
+                options.append(("grpc.ssl_target_name_override", ep.tls_server_name))
+            creds = channel_credentials(ep.ca_cert, ep.client_cert, ep.client_key)
+            return grpc.aio.secure_channel(ep.address, creds, options=options)
+        return grpc.aio.insecure_channel(ep.address, options=options)
+
+    async def __aenter__(self) -> RemoteExecClient:
+        self._channel = self._make_channel()
+        self._stub = pb_grpc.RemoteExecutorStub(self._channel)
+        return self
+
+    async def __aexit__(self, *exc) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        if self._channel is not None:
+            await self._channel.close()
+            self._channel = None
+
+    async def server_info(self) -> pb.ServerInfo:
+        assert self._stub, "use 'async with RemoteExecClient(...)'"
+        try:
+            return await self._stub.GetServerInfo(
+                pb.GetServerInfoRequest(), metadata=self._metadata, timeout=self.connect_timeout
+            )
+        except grpc.aio.AioRpcError as err:
+            raise self._error(err) from None
+
+    def _error(self, err: grpc.aio.AioRpcError) -> RemoteExecError:
+        msg = _describe_rpc_error(self.endpoint, err)
+        if err.code() in (grpc.StatusCode.UNAVAILABLE, grpc.StatusCode.DEADLINE_EXCEEDED):
+            return ServerUnavailable(msg)
+        if err.code() == grpc.StatusCode.PERMISSION_DENIED:
+            return CommandRejected(msg)
+        return RemoteExecError(msg)
+
+    async def execute(
+        self,
+        command: str,
+        cwd: str | None = None,
+        env: Mapping[str, str] | None = None,
+        timeout: float | None = None,
+    ) -> AsyncIterator[pb.ExecuteEvent]:
+        """Yield raw ExecuteEvent messages as they arrive.
+
+        Closing the iterator early (or cancelling the task) cancels the RPC,
+        which makes the server terminate the remote process group.
+        """
+        assert self._stub, "use 'async with RemoteExecClient(...)'"
+        request = pb.ExecuteRequest(
+            command=command, working_directory=cwd or "", environment=dict(env or {}),
+            timeout_seconds=float(timeout or 0),
+        )
+        call = self._stub.Execute(request, metadata=self._metadata, wait_for_ready=False)
+        try:
+            # The server answers with Started right after spawning, so the first
+            # message doubles as a connection check with a bounded wait.
+            try:
+                first = await asyncio.wait_for(call.read(), self.connect_timeout)
+            except asyncio.TimeoutError:
+                raise ServerUnavailable(
+                    f"no response from {self.endpoint.address} within {self.connect_timeout:g}s"
+                ) from None
+            if first is grpc.aio.EOF:
+                raise RemoteExecError("server closed the stream without sending any event")
+            yield first
+            while (event := await call.read()) is not grpc.aio.EOF:
+                yield event
+        except grpc.aio.AioRpcError as err:
+            raise self._error(err) from None
+        finally:
+            if not call.done():
+                call.cancel()
+
+    async def run(
+        self,
+        command: str,
+        cwd: str | None = None,
+        env: Mapping[str, str] | None = None,
+        timeout: float | None = None,
+        on_stdout: Callable[[bytes], None] | None = None,
+        on_stderr: Callable[[bytes], None] | None = None,
+    ) -> ExecutionResult:
+        """Run a command, forwarding output chunks to the callbacks."""
+        hostname = ""
+        events = self.execute(command, cwd=cwd, env=env, timeout=timeout)
+        try:
+            async for ev in events:
+                kind = ev.WhichOneof("event")
+                if kind == "stdout":
+                    if on_stdout:
+                        on_stdout(ev.stdout.data)
+                elif kind == "stderr":
+                    if on_stderr:
+                        on_stderr(ev.stderr.data)
+                elif kind == "started":
+                    hostname = ev.started.hostname
+                elif kind == "finished":
+                    f = ev.finished
+                    return ExecutionResult(
+                        status=_STATUS_NAMES.get(f.status, "error"),
+                        exit_code=f.exit_code,
+                        signal=f.signal,
+                        message=f.message,
+                        execution_id=f.execution_id,
+                        hostname=hostname,
+                        start_time=f.start_time.ToDatetime() if f.HasField("start_time") else None,
+                        end_time=f.end_time.ToDatetime() if f.HasField("end_time") else None,
+                    )
+        finally:
+            await events.aclose()
+        raise RemoteExecError("stream ended without a final status (server crashed or connection lost)")

remote_exec/client_cli.py

@@ -0,0 +1,226 @@
+"""``remote-exec-client`` command line entry point."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import signal
+import sys
+
+from . import __version__
+from .client import (
+    EXIT_CLIENT_ERROR,
+    EXIT_INTERRUPTED,
+    EXIT_REJECTED,
+    CommandRejected,
+    RemoteExecClient,
+    RemoteExecError,
+    ServerUnavailable,
+)
+from .config import ClientConfig, ConfigError, default_client_config_path, load_client_config
+from .security import SecurityError
+from .skill import DEFAULT_SKILL_DIR, SKILL_NAME, SkillExistsError, install_skill
+
+PROG = "remote-exec-client"
+
+EPILOG = f"""\
+exit status:
+  N     the remote command's exit status (128+N if killed by signal N)
+  124   the command timed out (--timeout)
+  126   the server's tools policy does not allow a program in the command
+        (see the allow/deny lists shown by --ping)
+  130   interrupted locally (Ctrl-C); the remote command is terminated
+  255   remote-exec error: config, connection, authentication, or the command
+        could not be started (message on stderr)
+
+default config: {default_client_config_path()}  (override with --config or $REMOTE_EXEC_CONFIG)
+
+examples:
+  {PROG} fpga01 hostname
+  {PROG} fpga01 --cwd /home/user/project "vivado -mode batch -source build.tcl"
+  {PROG} fpga01 -e FPGA_PART=xcvu37p -e BUILD_MODE=release ./build.sh
+  {PROG} gpu01 --timeout 60 -- nvidia-smi -L
+  {PROG} --list
+  {PROG} --install-skill        # teach Claude Code to use this tool
+"""
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog=PROG,
+        description="Run a shell command on a remote-exec-server and stream its stdout/stderr, "
+        "exiting with the remote exit status (like ssh).",
+        epilog=EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("server", nargs="?", help="server name from the config, or HOST[:PORT] (default port 50051)")
+    p.add_argument("command", nargs="*", help="command line; multiple words are joined with spaces (like ssh)")
+    p.add_argument("-C", "--cwd", metavar="DIR", help="remote working directory (absolute, or ~/...)")
+    p.add_argument("-e", "--env", metavar="KEY=VALUE", action="append", default=[],
+                   help="set a remote environment variable (repeatable); bare KEY copies the local value")
+    p.add_argument("-t", "--timeout", type=float, metavar="SECONDS",
+                   help="kill the remote command (and its children) after SECONDS")
+    p.add_argument("-c", "--config", metavar="FILE", help="client config file")
+    p.add_argument("--connect-timeout", type=float, metavar="SECONDS",
+                   help="max wait for the server to accept the command (default: 10)")
+    p.add_argument("--verbose", action="store_true", help="print execution summary to stderr")
+    p.add_argument("--list", action="store_true", help="list configured servers and exit")
+    p.add_argument("--ping", action="store_true", help="check that SERVER is reachable and show its info")
+    p.add_argument("--install-skill", nargs="?", const=str(DEFAULT_SKILL_DIR), metavar="DIR",
+                   help=f"install the '{SKILL_NAME}' Claude Code skill as DIR/{SKILL_NAME}.md "
+                   f"(default DIR: {DEFAULT_SKILL_DIR}) and exit")
+    p.add_argument("--force", action="store_true", help="with --install-skill: overwrite an existing, modified skill")
+    p.add_argument("-v", "--version", action="version", version=f"%(prog)s {__version__}")
+    return p
+
+
+def do_install_skill(directory: str, force: bool) -> int:
+    try:
+        path, status = install_skill(directory, force=force)
+    except SkillExistsError as exc:
+        err(f"error: {exc}")
+        return 1
+    except OSError as exc:
+        err(f"error: cannot install skill: {exc}")
+        return 1
+    if status == "unchanged":
+        print(f"skill already up to date: {path}")
+    else:
+        print(f"skill {status}: {path}")
+        print(f"Claude Code can now use it automatically, or invoke it with /{SKILL_NAME}")
+    return 0
+
+
+def parse_env(items: list[str]) -> dict[str, str]:
+    env = {}
+    for item in items:
+        key, sep, value = item.partition("=")
+        if not key:
+            raise ConfigError(f"invalid --env {item!r}, expected KEY=VALUE")
+        if not sep:
+            if key not in os.environ:
+                raise ConfigError(f"--env {key}: not set in the local environment")
+            value = os.environ[key]
+        env[key] = value
+    return env
+
+
+def err(msg: str) -> None:
+    print(f"{PROG}: {msg}", file=sys.stderr, flush=True)
+
+
+def _write(stream):
+    def write(data: bytes) -> None:
+        stream.write(data)
+        stream.flush()
+    return write
+
+
+def list_servers(config: ClientConfig) -> int:
+    if not config.servers:
+        where = config.path or default_client_config_path()
+        print(f"no servers configured (config: {where})")
+        return 0
+    width = max(len(n) for n in config.servers)
+    for name, ep in config.servers.items():
+        line = f"{name:<{width}}  {ep.address}"
+        if ep.description:
+            line += f"  {ep.description}"
+        print(line)
+    return 0
+
+
+async def _ping(client: RemoteExecClient) -> int:
+    info = await client.server_info()
+    print(f"{client.endpoint.name}: ok host={info.hostname} user={info.user} version={info.version} shell={info.shell}")
+    print(f"  allowed programs: {', '.join(info.allowed_tools) or '(none)'}")
+    print(f"  denied programs:  {', '.join(info.denied_tools) or '(none)'}")
+    return 0
+
+
+async def _execute(client: RemoteExecClient, args, command: str, env: dict[str, str]) -> int:
+    result = await client.run(
+        command, cwd=args.cwd, env=env, timeout=args.timeout,
+        on_stdout=_write(sys.stdout.buffer), on_stderr=_write(sys.stderr.buffer),
+    )
+    name = client.endpoint.name
+    if result.status == "timeout":
+        err(f"{name}: {result.message or 'command timed out'}; remote process group terminated")
+    elif result.status == "error":
+        err(f"{name}: {result.message or 'remote execution failed'}")
+    elif result.signal:
+        err(f"{name}: remote command killed by signal {result.signal}")
+    if args.verbose:
+        dur = f"{result.duration:.3f}s" if result.duration is not None else "?"
+        err(f"{name}: host={result.hostname} status={result.status} exit_code={result.exit_code} "
+            f"duration={dur} id={result.execution_id}")
+    return result.local_exit_code
+
+
+async def _main_async(args, endpoint, command: str | None, env: dict[str, str]) -> int:
+    task = asyncio.current_task()
+    loop = asyncio.get_running_loop()
+    # SIGTERM (e.g. from an agent's tool timeout) cancels the RPC cleanly so the
+    # server kills the remote command right away.
+    loop.add_signal_handler(signal.SIGTERM, task.cancel)
+    async with RemoteExecClient(endpoint, connect_timeout=args.connect_timeout) as client:
+        if args.ping:
+            return await _ping(client)
+        return await _execute(client, args, command, env)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_intermixed_args(argv)
+    if args.install_skill:
+        return do_install_skill(args.install_skill, args.force)
+
+    try:
+        config = load_client_config(args.config)
+        if args.list:
+            return list_servers(config)
+        if not args.server:
+            parser.error("missing SERVER")
+        command = " ".join(args.command)
+        if not args.ping and not command.strip():
+            parser.error("missing COMMAND")
+        if args.timeout is not None and args.timeout <= 0:
+            parser.error("--timeout must be > 0")
+        env = parse_env(args.env)
+        endpoint = config.resolve(args.server)
+    except (ConfigError, SecurityError) as exc:
+        err(f"error: {exc}")
+        return EXIT_CLIENT_ERROR
+
+    try:
+        return asyncio.run(_main_async(args, endpoint, command, env))
+    except KeyboardInterrupt:
+        err("interrupted; remote command cancelled")
+        return EXIT_INTERRUPTED
+    except asyncio.CancelledError:
+        err("terminated; remote command cancelled")
+        return 128 + signal.SIGTERM
+    except ServerUnavailable as exc:
+        hint = ""
+        if args.server not in config.servers and not any(c in args.server for c in ".:"):
+            hint = f" ('{args.server}' is not a configured server name; config: {config.path or default_client_config_path()})"
+        err(f"error: {exc}{hint}")
+        return EXIT_CLIENT_ERROR
+    except CommandRejected as exc:
+        err(f"error: {exc}")
+        return EXIT_REJECTED
+    except (RemoteExecError, SecurityError) as exc:
+        err(f"error: {exc}")
+        return EXIT_CLIENT_ERROR
+    except BrokenPipeError:
+        # Local stdout closed (e.g. piped into `head`); the RPC was cancelled.
+        try:
+            sys.stdout = open(os.devnull, "w")
+        except OSError:
+            pass
+        return 141
+
+
+if __name__ == "__main__":
+    sys.exit(main())