Download external/kimina-lean-server/server/manager.py from Harryis/RAGEN: direct link, hf CLI and curl.
- Browser
- Download file 8.3 kB
-
https://huggingface.co/datasets/Harryis/RAGEN/resolve/main/external/kimina-lean-server/server/manager.py
- Command line
-
hf download hf://datasets/Harryis/RAGEN/external/kimina-lean-server/server/manager.py
-
curl -L -o manager.py https://huggingface.co/datasets/Harryis/RAGEN/resolve/main/external/kimina-lean-server/server/manager.py
8.3 kB
| from __future__ import annotations | |
| import asyncio | |
| import json | |
| from datetime import datetime | |
| from time import time | |
| from kimina_client import ReplResponse, Snippet | |
| from loguru import logger | |
| from .errors import NoAvailableReplError, ReplError | |
| from .repl import Repl, close_verbose | |
| from .settings import settings | |
| from .utils import is_blank | |
| class Manager: | |
| def __init__( | |
| self, | |
| *, | |
| max_repls: int = settings.max_repls, | |
| max_repl_uses: int = settings.max_repl_uses, | |
| max_repl_mem: int = settings.max_repl_mem, | |
| init_repls: dict[str, int] = settings.init_repls, | |
| ) -> None: | |
| self.max_repls = max_repls | |
| self.max_repl_uses = max_repl_uses | |
| self.max_repl_mem = max_repl_mem | |
| self.init_repls = init_repls | |
| self._lock: asyncio.Lock | None = None | |
| self._cond: asyncio.Condition | None = None | |
| self._free: list[Repl] = [] | |
| self._busy: set[Repl] = set() | |
| logger.info( | |
| "REPL manager initialized with: MAX_REPLS={}, MAX_REPL_USES={}, MAX_REPL_MEM={} MB", | |
| max_repls, | |
| max_repl_uses, | |
| max_repl_mem, | |
| ) | |
| def _ensure_lock(self) -> None: | |
| """Ensure the lock and condition are initialized in an async context.""" | |
| if self._lock is None: | |
| self._lock = asyncio.Lock() | |
| self._cond = asyncio.Condition(self._lock) | |
| async def initialize_repls(self) -> None: | |
| if len(self.init_repls) == 0: | |
| return | |
| if self.max_repls < sum(self.init_repls.values()): | |
| raise ValueError( | |
| f"Cannot initialize REPLs: Σ (INIT_REPLS values) = {sum(self.init_repls.values())} > {self.max_repls} = MAX_REPLS" | |
| ) | |
| initialized_repls: list[Repl] = [] | |
| for header, count in self.init_repls.items(): | |
| for _ in range(count): | |
| initialized_repls.append(await self.get_repl(header=header)) | |
| async def _prep_and_release(repl: Repl) -> None: | |
| # All initialized imports should finish in 60 seconds. | |
| await self.prep(repl, snippet_id="init", timeout=60, debug=False) | |
| await self.release_repl(repl) | |
| await asyncio.gather(*(_prep_and_release(r) for r in initialized_repls)) | |
| logger.info(f"Initialized REPLs with: {json.dumps(self.init_repls, indent=2)}") | |
| async def get_repl( | |
| self, | |
| header: str = "", | |
| snippet_id: str = "", | |
| timeout: float = settings.max_wait, | |
| reuse: bool = True, | |
| ) -> Repl: | |
| """ | |
| Async-safe way to get a `Repl` instance for a given header. | |
| Immediately raises an Exception if not possible. | |
| """ | |
| self._ensure_lock() | |
| assert self._cond is not None # Type narrowing after _ensure_lock | |
| deadline = time() + timeout | |
| repl_to_destroy: Repl | None = None | |
| while True: | |
| async with self._cond: | |
| logger.info( | |
| f"# Free = {len(self._free)} | # Busy = {len(self._busy)} | # Max = {self.max_repls}" | |
| ) | |
| if reuse: | |
| for i, r in enumerate(self._free): | |
| if ( | |
| r.header == header | |
| ): # repl shouldn't be exhausted (max uses to check) | |
| repl = self._free.pop(i) | |
| self._busy.add(repl) | |
| logger.info( | |
| f"\\[{repl.uuid.hex[:8]}] Reusing ({'started' if repl.is_running else 'non-started'}) REPL for {snippet_id}" | |
| ) | |
| return repl | |
| total = len(self._free) + len(self._busy) | |
| if total < self.max_repls: | |
| break | |
| if self._free: | |
| oldest = min( | |
| self._free, key=lambda r: r.last_check_at | |
| ) # Use the one that's been around the longest | |
| self._free.remove(oldest) | |
| repl_to_destroy = oldest | |
| break | |
| remaining = deadline - time() | |
| if remaining <= 0: | |
| raise NoAvailableReplError(f"Timed out after {timeout}s") | |
| try: | |
| logger.info( | |
| f"Waiting for a REPL to become available (timeout in {remaining:.2f}s)" | |
| ) | |
| # Wait for a REPL to be released | |
| await asyncio.wait_for(self._cond.wait(), timeout=remaining) | |
| except asyncio.TimeoutError: | |
| raise NoAvailableReplError( | |
| f"Timed out after {timeout}s while waiting for a REPL" | |
| ) from None | |
| if repl_to_destroy is not None: | |
| asyncio.create_task(close_verbose(repl_to_destroy)) | |
| return await self.start_new(header) | |
| async def destroy_repl(self, repl: Repl) -> None: | |
| self._ensure_lock() | |
| assert self._cond is not None # Type narrowing after _ensure_lock | |
| async with self._cond: | |
| self._busy.discard(repl) | |
| if repl in self._free: | |
| self._free.remove(repl) | |
| asyncio.create_task(close_verbose(repl)) | |
| self._cond.notify(1) | |
| async def release_repl(self, repl: Repl) -> None: | |
| self._ensure_lock() | |
| assert self._cond is not None # Type narrowing after _ensure_lock | |
| async with self._cond: | |
| if repl not in self._busy: | |
| logger.error( | |
| f"Attempted to release a REPL that is not busy: {repl.uuid.hex[:8]}" | |
| ) | |
| return | |
| if repl.exhausted: | |
| uuid = repl.uuid | |
| logger.info(f"REPL {uuid.hex[:8]} is exhausted, closing it") | |
| self._busy.discard(repl) | |
| asyncio.create_task(close_verbose(repl)) | |
| self._cond.notify(1) | |
| return | |
| self._busy.remove(repl) | |
| self._free.append(repl) | |
| repl.last_check_at = datetime.now() | |
| logger.info(f"\\[{repl.uuid.hex[:8]}] Released!") | |
| self._cond.notify(1) | |
| async def start_new(self, header: str) -> Repl: | |
| repl = await Repl.create( | |
| header, max_repl_uses=self.max_repl_uses, max_repl_mem=self.max_repl_mem | |
| ) | |
| self._busy.add(repl) | |
| return repl | |
| async def cleanup(self) -> None: | |
| self._ensure_lock() | |
| assert self._cond is not None # Type narrowing after _ensure_lock | |
| async with self._cond: | |
| logger.info("Cleaning up REPL manager...") | |
| for repl in self._free: | |
| asyncio.create_task(close_verbose(repl)) | |
| self._free.clear() | |
| for repl in self._busy: | |
| asyncio.create_task(close_verbose(repl)) | |
| self._busy.clear() | |
| logger.info("REPL manager cleaned up!") | |
| pass | |
| async def prep( | |
| self, repl: Repl, snippet_id: str, timeout: float, debug: bool | |
| ) -> ReplResponse | None: | |
| if repl.is_running: | |
| return None | |
| try: | |
| await repl.start() | |
| except Exception as e: | |
| logger.exception("Failed to start REPL: %s", e) | |
| raise ReplError("Failed to start REPL") from e | |
| if not is_blank(repl.header): | |
| try: | |
| cmd_response = await repl.send_timeout( | |
| Snippet(id=f"{snippet_id}-header", code=repl.header), | |
| timeout=timeout, | |
| is_header=True, | |
| ) | |
| except TimeoutError as e: | |
| logger.error("Header command timed out") | |
| raise e | |
| except Exception as e: | |
| logger.error("Failed to run header on REPL") | |
| raise ReplError("Failed to run header on REPL") from e | |
| if not debug: | |
| cmd_response.diagnostics = None | |
| if cmd_response.error: | |
| logger.error(f"Header command failed: {cmd_response.error}") | |
| await self.destroy_repl(repl) | |
| repl.header_cmd_response = cmd_response | |
| return cmd_response | |
| return repl.header_cmd_response | |