Datasets:
Download source/fdesk/environment.py from bpHigh/finance-desk: direct link, hf CLI and curl.
- Browser
- Download file 6.35 kB
-
https://huggingface.co/datasets/bpHigh/finance-desk/resolve/main/source/fdesk/environment.py
- Command line
-
hf download hf://datasets/bpHigh/finance-desk/source/fdesk/environment.py
-
curl -L -o environment.py https://huggingface.co/datasets/bpHigh/finance-desk/resolve/main/source/fdesk/environment.py
6.35 kB
| """Finance Desk environment: one procedural workspace per episode, four tools, all-or-nothing reward.""" | |
| import os | |
| import random | |
| import shutil | |
| import tempfile | |
| import time | |
| from typing import Any, Optional | |
| from uuid import uuid4 | |
| from openenv.core.env_server.interfaces import Environment | |
| from openenv.core.env_server.types import State | |
| from .families import FAMILIES, parse_task_id, task_ids | |
| from .families.base import grade | |
| from .models import DeskAction, DeskObservation | |
| from .sandbox import prepare_workspace, run_python | |
| MAX_STEPS = 8 | |
| MAX_READ = 6000 | |
| # Unseeded resets in the same 10-minute window get the same instance, so the parallel episodes of one GRPO | |
| # group (separate sandboxes started together) compare answers to one problem. | |
| SEED_WINDOW_S = 600 | |
| # v2: embed every file's contents in the first observation (like the top MetaHarness env) so a task can be | |
| # answered in one step with no reading turns. The python tool stays available for heavy arithmetic. | |
| INLINE_FILES = True | |
| MAX_INLINE = 6000 # per-file cap when inlining (keeps the observation inside the context budget) | |
| TOOLS_HELP = ( | |
| 'Reply with ONE JSON object. To answer: {"tool": "submit", "args": {"answer": {...the documented keys...}}} ' | |
| "— graded once, all-or-nothing (reward 1 only if every field is exactly right, else 0). " | |
| 'If you need to compute, first call {"tool": "python", "args": {"code": "..."}} (the files are in the current ' | |
| "directory; numpy and pandas available; print what you need; 10 s limit). You may reason first, but your reply " | |
| f"must end with exactly one JSON object and nothing after it. You have {MAX_STEPS} replies." | |
| ) | |
| class FinanceDeskEnvironment(Environment): | |
| SUPPORTS_CONCURRENT_SESSIONS: bool = True | |
| def __init__(self): | |
| self._state = State(episode_id=str(uuid4()), step_count=0) | |
| self._workspace: Optional[str] = None | |
| self._instance = None | |
| self._done = True | |
| self._task_id = "" | |
| # ------------------------------------------------------------------ lifecycle | |
| def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, task_id: Optional[str] = None, | |
| **kwargs: Any) -> DeskObservation: | |
| task_id = task_id or kwargs.get("task") or task_ids()[0] | |
| family, level = parse_task_id(task_id) | |
| if seed is None: | |
| seed = int(time.time() // SEED_WINDOW_S) | |
| self._cleanup() | |
| self._instance = family.generate(random.Random(f"{task_id}:{seed}"), level) | |
| self._task_id = task_id | |
| self._workspace = tempfile.mkdtemp(prefix="desk_") | |
| for name, text in self._instance.files.items(): | |
| with open(os.path.join(self._workspace, name), "w") as f: | |
| f.write(text) | |
| prepare_workspace(self._workspace) | |
| self._state = State(episode_id=episode_id or str(uuid4()), step_count=0) | |
| self._done = False | |
| if INLINE_FILES: | |
| blocks = [] | |
| for n, t in sorted(self._instance.files.items()): | |
| body = t if len(t) <= MAX_INLINE else t[:MAX_INLINE] + f"\n[truncated; read {n} with python for the rest]" | |
| blocks.append(f"=== {n} ===\n{body}") | |
| files_section = "FILES (full contents):\n" + "\n".join(blocks) | |
| else: | |
| files_section = "Workspace files: " + ", ".join( | |
| f"{n} ({len(t)} chars)" for n, t in sorted(self._instance.files.items())) | |
| brief = f"Task [{family.title}]: {self._instance.prompt}\n\n{files_section}\n\n{TOOLS_HELP}" | |
| return DeskObservation(output=brief, steps_left=MAX_STEPS, done=False, reward=0.0) | |
| def step(self, action: DeskAction, timeout_s: Optional[float] = None, **kwargs: Any) -> DeskObservation: # type: ignore[override] | |
| if self._done or self._instance is None: | |
| return DeskObservation(output="Episode is over; call reset.", steps_left=0, done=True, reward=0.0) | |
| self._state.step_count += 1 | |
| left = MAX_STEPS - self._state.step_count | |
| tool = (action.tool or "").strip().lower() | |
| args = action.args or {} | |
| if tool == "submit": | |
| answer = args.get("answer", {k: v for k, v in args.items()}) | |
| if getattr(self._instance, "grader", None): | |
| ok = bool(self._instance.grader(answer)) | |
| else: | |
| ok = grade(self._instance.answer, answer, self._instance.specs) | |
| return self._finish("Submitted. " + ("Correct." if ok else "Not correct."), 1.0 if ok else 0.0) | |
| if tool == "list": | |
| out = "\n".join(f"{n}\t{len(t)} chars" for n, t in sorted(self._instance.files.items())) | |
| elif tool == "read": | |
| paths = args.get("paths") or [args.get("path") or args.get("file") or ""] | |
| if isinstance(paths, str): | |
| paths = [paths] | |
| out = "\n".join(self._read(str(p)) for p in paths[:6]) | |
| elif tool in ("python", "py", "run_python"): | |
| code = args.get("code") or args.get("source") or "" | |
| out = run_python(self._workspace, str(code)) if code else "error: python needs {\"code\": \"...\"}" | |
| else: | |
| out = f"error: unknown tool {tool!r}. Use list, read, python or submit." | |
| if left <= 0: | |
| return self._finish(out + "\nNo tool calls left; episode ended without a submission.", 0.0) | |
| return DeskObservation(output=out, steps_left=left, done=False, reward=0.0) | |
| def _read(self, path: str) -> str: | |
| name = os.path.basename(path.strip()) | |
| if name not in self._instance.files: | |
| return f"== {path}: no such file (files: {', '.join(sorted(self._instance.files))})" | |
| text = self._instance.files[name] | |
| if len(text) > MAX_READ: | |
| text = text[:MAX_READ] + f"\n[truncated at {MAX_READ} chars; use python to read the rest]" | |
| return f"== {name}\n{text}" | |
| def _finish(self, msg: str, reward: float) -> DeskObservation: | |
| self._done = True | |
| self._cleanup() | |
| return DeskObservation(output=msg, steps_left=0, done=True, reward=reward) | |
| def _cleanup(self) -> None: | |
| if self._workspace: | |
| shutil.rmtree(self._workspace, ignore_errors=True) | |
| self._workspace = None | |
| def close(self) -> None: | |
| self._cleanup() | |
| def state(self) -> State: | |
| return self._state | |