| """Killable external execution boundary for ModeBench Python functions.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| import os |
| from pathlib import Path |
| import select |
| import subprocess |
| import sys |
| import threading |
| from typing import Any, Mapping |
|
|
| from .python_modebench import PythonFactorValidation |
|
|
|
|
| class PythonFactorVerifierProcess: |
| """Execute restricted candidate functions outside the trainer process.""" |
|
|
| def __init__(self, *, timeout_seconds: float = 1.0) -> None: |
| if timeout_seconds <= 0: |
| raise ValueError("timeout_seconds must be positive") |
| self.timeout_seconds = float(timeout_seconds) |
| self._process: subprocess.Popen[str] | None = None |
| self._owner_pid = os.getpid() |
| self._lock = threading.Lock() |
|
|
| def _start(self) -> subprocess.Popen[str]: |
| if self._owner_pid != os.getpid(): |
| self._process = None |
| self._owner_pid = os.getpid() |
| process = self._process |
| if process is not None and process.poll() is None: |
| return process |
| worker_env = os.environ.copy() |
| source_root = str(Path(__file__).resolve().parents[1]) |
| inherited_pythonpath = worker_env.get("PYTHONPATH") |
| worker_env["PYTHONPATH"] = ( |
| source_root |
| if not inherited_pythonpath |
| else source_root + os.pathsep + inherited_pythonpath |
| ) |
| isolated_entrypoint = ( |
| "import runpy,sys;" |
| f"sys.path.insert(0,{source_root!r});" |
| "runpy.run_module('oat_drgrpo.python_modebench_worker',run_name='__main__')" |
| ) |
| self._process = subprocess.Popen( |
| [sys.executable, "-I", "-c", isolated_entrypoint], |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE, |
| stderr=None, |
| text=True, |
| encoding="utf-8", |
| bufsize=1, |
| start_new_session=True, |
| env=worker_env, |
| ) |
| return self._process |
|
|
| def _stop(self) -> None: |
| process, self._process = self._process, None |
| if process is None: |
| return |
| if process.poll() is None: |
| process.terminate() |
| try: |
| process.wait(timeout=1) |
| except subprocess.TimeoutExpired: |
| process.kill() |
| process.wait(timeout=1) |
| if process.stdin is not None: |
| process.stdin.close() |
| if process.stdout is not None: |
| process.stdout.close() |
|
|
| def close(self) -> None: |
| with self._lock: |
| self._stop() |
|
|
| def validate( |
| self, |
| candidate: str, |
| spec: Mapping[str, Any], |
| ) -> PythonFactorValidation | None: |
| request = json.dumps( |
| {"candidate": str(candidate), "spec": dict(spec)}, |
| allow_nan=False, |
| ) |
| with self._lock: |
| for attempt in range(2): |
| process = self._start() |
| try: |
| assert process.stdin is not None and process.stdout is not None |
| process.stdin.write(request + "\n") |
| process.stdin.flush() |
| readable, _, _ = select.select( |
| [process.stdout], [], [], self.timeout_seconds |
| ) |
| if not readable: |
| self._stop() |
| return None |
| line = process.stdout.readline() |
| if not line: |
| raise BrokenPipeError("Python ModeBench worker closed stdout") |
| payload = json.loads(line) |
| if not payload.get("valid"): |
| return None |
| return PythonFactorValidation( |
| canonical_key=str(payload["canonical_key"]), |
| outputs=tuple(int(value) for value in payload["outputs"]), |
| ) |
| except (BrokenPipeError, OSError, ValueError, json.JSONDecodeError): |
| self._stop() |
| if attempt: |
| return None |
| return None |
|
|
| def __del__(self) -> None: |
| try: |
| self._stop() |
| except Exception: |
| pass |
|
|
|
|
| _SHARED_VERIFIER = PythonFactorVerifierProcess() |
|
|
|
|
| def validate_python_factor_function_external( |
| candidate: str, |
| spec: Mapping[str, Any], |
| ) -> PythonFactorValidation | None: |
| """Validate a candidate through the shared external Python worker.""" |
|
|
| return _SHARED_VERIFIER.validate(candidate, spec) |
|
|
