Download external/kimina-lean-server/server/server_old/leanrepl.py from Harryis/RAGEN: direct link, hf CLI and curl.
- Browser
- Download file 7.78 kB
-
https://huggingface.co/datasets/Harryis/RAGEN/resolve/main/external/kimina-lean-server/server/server_old/leanrepl.py
- Command line
-
hf download hf://datasets/Harryis/RAGEN/external/kimina-lean-server/server/server_old/leanrepl.py
-
curl -L -o leanrepl.py https://huggingface.co/datasets/Harryis/RAGEN/resolve/main/external/kimina-lean-server/server/server_old/leanrepl.py
7.78 kB
| import json | |
| import os | |
| import signal | |
| import subprocess | |
| import tempfile | |
| import threading | |
| import time | |
| import psutil | |
| import resource | |
| from func_timeout import FunctionTimedOut, func_timeout # type: ignore | |
| from loguru import logger | |
| from utils.proof_utils import get_error_msg | |
| from .config import settings | |
| base = settings.WORKSPACE | |
| path_to_repl = f"{base}/repl/.lake/build/bin/repl" | |
| path_to_mathlib = f"{base}/mathlib4" | |
| # error for lean crashes | |
| class LeanCrashError(Exception): | |
| pass | |
| class LeanREPL: | |
| def __init__(self): | |
| # Start the REPL process | |
| self.error_file = tempfile.TemporaryFile( | |
| "w+", | |
| ) | |
| self.start_process() | |
| # Create a lock for thread safety | |
| self.lock = threading.Lock() | |
| self.header = None | |
| self.psutil_process = None | |
| self.children_processes = [] | |
| self.run_command_total = 0 | |
| def _send_command(self, command): | |
| """ | |
| Send a JSON command to the REPL and return the JSON response. | |
| """ | |
| with self.lock: | |
| try: | |
| self.run_command_total += 1 | |
| # Convert the command to JSON and add two newlines | |
| json_command = json.dumps(command, ensure_ascii=False) + "\n\n" | |
| # Send the command to the REPL | |
| time_elapsed = time.time() | |
| self.process.stdin.write(json_command) | |
| self.process.stdin.flush() | |
| # Read the response until a blank line is encountered | |
| response_lines = [] | |
| stderr_lines = [] | |
| while True: | |
| # Read from both stdout and stderr | |
| stdout_line = self.process.stdout.readline() | |
| if stdout_line.strip() == "": | |
| break | |
| if stdout_line: | |
| response_lines.append(stdout_line) | |
| except BrokenPipeError: | |
| raise LeanCrashError("Lean process broken pipe error") | |
| # Combine the response lines and parse the JSON | |
| response_str = "".join(response_lines) | |
| time_elapsed = time.time() - time_elapsed | |
| try: | |
| response_json = json.loads(response_str) | |
| except json.JSONDecodeError as e: | |
| logger.error("Error decoding JSON:", e) | |
| logger.error("Response received:", response_str) | |
| response_json = { | |
| "messages": [ | |
| { | |
| "severity": "error", | |
| "data": "error decoding json response in leanrepl", | |
| } | |
| ] | |
| } | |
| error_content = self.get_error_content() | |
| if len(error_content.strip()) > 0: | |
| logger.error("Error from stderr: %s", error_content) | |
| raise LeanCrashError( | |
| f"Lean process encountered an error: {error_content}" | |
| ) | |
| response_json["time"] = time_elapsed | |
| return response_json | |
| def one_pass_verify(self, code, timeout, infotree_type=None): | |
| """ | |
| Send code to verify in one pass. | |
| """ | |
| if infotree_type is None: | |
| command = {"cmd": code, "gc": True} | |
| else: | |
| command = {"cmd": code, "infotree": infotree_type, "gc": True} | |
| try: | |
| response = func_timeout(timeout, self._send_command, args=(command,)) | |
| except FunctionTimedOut: | |
| raise LeanCrashError("Lean process timed out") | |
| return response | |
| def create_env(self, code, timeout=150): | |
| """ | |
| Send code to create a new context. | |
| """ | |
| command = {"cmd": code} | |
| try: | |
| response = func_timeout(timeout, self._send_command, args=(command,)) | |
| except FunctionTimedOut: | |
| raise LeanCrashError("Lean process timed out") | |
| if get_error_msg(response) is None: | |
| self.header = code | |
| return response | |
| def extend_env(self, context_id, code, timeout=150, infotree_type=None): | |
| """ | |
| Send code to extend a context. | |
| """ | |
| if infotree_type is None: | |
| command = {"cmd": code, "env": context_id, "gc": True} | |
| else: | |
| command = {"cmd": code, "env": context_id, "infotree": infotree_type, "gc": True} | |
| try: | |
| response = func_timeout(timeout, self._send_command, args=(command,)) | |
| except FunctionTimedOut: | |
| raise LeanCrashError("Lean process timed out") | |
| return response | |
| def start_process(self): | |
| def preexec_fn(): | |
| if settings.HARD_ENFORCE_MEMORY_LIMIT: | |
| soft_limit = settings.REPL_MEMORY_LIMIT_GB * 1024 * 1024 * 1024 | |
| hard_limit = soft_limit | |
| resource.setrlimit(resource.RLIMIT_AS, (soft_limit, hard_limit)) | |
| os.setsid() | |
| self.process = subprocess.Popen( | |
| ["lake", "env", path_to_repl], | |
| stdin=subprocess.PIPE, | |
| stdout=subprocess.PIPE, | |
| stderr=self.error_file, | |
| text=True, | |
| bufsize=1, # Line-buffered | |
| cwd=path_to_mathlib, # Set the working directory to 'mathlib4' | |
| env=os.environ, # Inherit environment variables | |
| preexec_fn=preexec_fn, | |
| ) | |
| def get_error_content(self): | |
| # Ensure that we seek back to the beginning of the file before reading | |
| if self.error_file is None: | |
| logger.debug("Error file is None") | |
| self.error_file.seek(0) | |
| return self.error_file.read() | |
| def close(self): | |
| """ | |
| Terminate the REPL process and all its child processes. | |
| """ | |
| try: | |
| # stop input to repl (which will result in the program loop for lean repl terminating) | |
| self.process.stdin.close() | |
| os.killpg(os.getpgid(self.process.pid), signal.SIGKILL) | |
| except ProcessLookupError: | |
| # Process already terminated | |
| pass | |
| finally: | |
| # Wait for the process to exit | |
| self.process.wait() | |
| def __del__(self): | |
| self.close() | |
| def exceeds_memory_limit(self, limit_gb): | |
| """ | |
| Check if the REPL process exceeds the given memory limit. | |
| Returns True if memory usage exceeds limit, False otherwise. | |
| """ | |
| if self.psutil_process is None: | |
| self.psutil_process = psutil.Process(self.process.pid) | |
| if self.psutil_process is not None: | |
| try: | |
| memory_usage = self.psutil_process.memory_info().rss | |
| try: | |
| if not self.children_processes: | |
| self.children_processes = self.psutil_process.children() | |
| if self.children_processes: | |
| child_memory = sum(child.memory_info().rss for child in self.children_processes) | |
| total_memory = memory_usage + child_memory | |
| else: | |
| total_memory = memory_usage | |
| except Exception as e: | |
| logger.error(f"Error getting child processes: {e}") | |
| total_memory = memory_usage | |
| logger.debug(f"REPL pid {self.process.pid} using {total_memory/1024/1024/1024:.2f}GB") | |
| return total_memory > limit_gb * 1024 * 1024 * 1024, total_memory | |
| except (psutil.NoSuchProcess, psutil.AccessDenied) as e: | |
| logger.error(f"Error accessing process: {e}") | |
| return False | |
| except Exception as e: | |
| logger.error(f"Error checking memory: {e}") | |
| return False | |
| return False | |