codefix-env 0.2.1__py3-none-any.whl

codefix_env/__init__.py

@@ -0,0 +1,80 @@
+"""
+CodeFix-Env — RL Environment for Automated Code Debugging
+==========================================================
+Quick start::
+    from codefix_env import CodeFixEnvironment, CodeFixAction, CodeFixClient
+    # Server-side (direct, no HTTP)
+    env = CodeFixEnvironment()
+    obs = env.reset(task_id="easy-001-missing-return")
+    result = env.step(CodeFixAction(action_type="run_tests"))
+    # Client-side (HTTP)
+    async with CodeFixClient("http://localhost:8000") as env:
+        obs = await env.reset()
+        result = await env.step(CodeFixAction(action_type="submit_fix"))
+"""
+
+__version__ = "0.2.1"
+__author__ = "Shailendra Dhakad"
+
+from codefix_env.client import CodeFixClient, SyncCodeFixClient
+from codefix_env.env import CodeFixEnvironment
+from codefix_env.models import (
+    ActionType,
+    BugCategory,
+    CodeFixAction,
+    CodeFixObservation,
+    CodeFixState,
+    Difficulty,
+    StepResult,
+    Task,
+    TestCase,
+    TestResult,
+)
+from codefix_env.rewards import RewardPipeline
+from codefix_env.tasks import list_tasks, load_task, random_task, task_count
+from codefix_env.utils.metrics import EpisodeMetrics, ScoringConfig
+
+__all__ = [
+    # Core
+    "CodeFixEnvironment",
+    "CodeFixClient",
+    "SyncCodeFixClient",
+    # Models
+    "CodeFixAction",
+    "CodeFixObservation",
+    "CodeFixState",
+    "StepResult",
+    "Task",
+    "TestCase",
+    "TestResult",
+    "ActionType",
+    "Difficulty",
+    "BugCategory",
+    # Rewards
+    "RewardPipeline",
+    "ScoringConfig",
+    "RewardMLP",
+    "EpisodeMetrics",
+    # Tasks
+    "load_task",
+    "random_task",
+    "list_tasks",
+    "task_count",
+]
+
+
+def __getattr__(name):
+    """
+    Lazy attribute access for RewardMLP only. RewardMLP lives in
+    utils/reward_model.py (a torch-only module kept separate from the
+    rest of the package) so that `import codefix_env` never pays torch's
+    import cost unless someone actually touches RewardMLP. This matters
+    most for sandboxed worker processes (utils/sandbox.py) that re-import
+    the whole package on every spawn, especially on Windows where
+    multiprocessing uses "spawn" instead of "fork".
+    """
+    if name == "RewardMLP":
+        from codefix_env.utils.reward_model import RewardMLP
+
+        return RewardMLP
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

codefix_env/cli.py

@@ -0,0 +1,83 @@
+"""
+CodeFix-Env CLI
+================
+Entry point registered in pyproject.toml as `codefix-server`.
+
+Previously pyproject.toml declared:
+    [project.scripts]
+    codefix-server = "codefix_env.cli:app"
+
+...but this module did not exist, so `pip install -e .` produced a broken
+console script. This file makes that entry point real.
+
+Usage:
+    codefix-server serve                 # start the API server
+    codefix-server serve --port 9000
+    codefix-server tasks                 # list all tasks
+    codefix-server info                  # print version + task counts
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from codefix_env import __version__
+from codefix_env.tasks import list_tasks, task_count
+
+app = typer.Typer(help="CodeFix-Env command line interface.")
+console = Console()
+
+
+@app.command()
+def serve(
+    host: str = typer.Option("0.0.0.0", help="Bind host."),
+    port: int = typer.Option(8000, help="Bind port."),
+    reload: bool = typer.Option(False, help="Auto-reload on code changes (dev only)."),
+) -> None:
+    """Start the CodeFix-Env FastAPI server."""
+    import sys
+    from pathlib import Path
+
+    import uvicorn
+
+    # `server/` lives at the repo root, not under src/, so it isn't on
+    # sys.path just because codefix_env is pip-installed. Add the repo
+    # root explicitly so `server.app:app` is importable regardless of
+    # cwd or PYTHONPATH — this was silently broken before (CI only
+    # tested `codefix-server info`, never `serve`, so it went unnoticed).
+    repo_root = Path(__file__).resolve().parents[2]
+    if str(repo_root) not in sys.path:
+        sys.path.insert(0, str(repo_root))
+
+    uvicorn.run("server.app:app", host=host, port=port, reload=reload)
+
+
+@app.command()
+def tasks(
+    difficulty: str = typer.Option(None, help="Filter: easy | medium | hard"),
+) -> None:
+    """List all available debugging tasks."""
+    from codefix_env.models import Difficulty
+
+    diff_filter = Difficulty(difficulty) if difficulty else None
+    table = Table(title="CodeFix-Env Tasks")
+    table.add_column("ID")
+    table.add_column("Title")
+    table.add_column("Difficulty")
+    table.add_column("Category")
+    for t in list_tasks(difficulty=diff_filter):
+        table.add_row(t.id, t.title, str(t.difficulty), str(t.bug_category))
+    console.print(table)
+
+
+@app.command()
+def info() -> None:
+    """Print version and task counts."""
+    console.print(f"[bold]codefix-env[/bold] v{__version__}")
+    console.print(task_count())
+
+
+if __name__ == "__main__":
+    app()

codefix_env/client.py

@@ -0,0 +1,194 @@
+"""
+CodeFixClient — Async & Sync HTTP Client
+=========================================
+Communicates with the CodeFix-Env FastAPI server via HTTP + WebSocket.
+
+Usage::
+
+    # Async (recommended for RL training loops)
+    async with CodeFixClient("http://localhost:8000") as env:
+        obs = await env.reset()
+        result = await env.step(CodeFixAction(action_type="run_tests"))
+
+    # Sync (via .sync() wrapper — for notebooks and scripts)
+    with CodeFixClient("http://localhost:8000").sync() as env:
+        obs = env.reset()
+        result = env.step(CodeFixAction(action_type="run_tests"))
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+import httpx
+
+from codefix_env.models import (
+    CodeFixAction,
+    CodeFixObservation,
+    CodeFixState,
+    Difficulty,
+    StepResult,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CodeFixClient:
+    """
+    Async HTTP client for the CodeFix-Env server.
+    Provides the same reset() / step() / state() interface as the server-side env.
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8000",
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._client: httpx.AsyncClient | None = None
+
+    # ── Context manager ───────────────────────────────────────────────────────
+
+    async def __aenter__(self) -> CodeFixClient:
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            timeout=self.timeout,
+        )
+        # Health check
+        try:
+            r = await self._client.get("/health")
+            r.raise_for_status()
+            logger.info("Connected to CodeFix-Env at %s", self.base_url)
+        except Exception as e:
+            logger.warning("Health check failed: %s. Proceeding anyway.", e)
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    # ── Core API ──────────────────────────────────────────────────────────────
+
+    async def reset(
+        self,
+        task_id: str | None = None,
+        difficulty: Difficulty | None = None,
+        seed: int | None = None,
+    ) -> CodeFixObservation:
+        """Reset the environment and return the initial observation."""
+        payload: dict = {}
+        if task_id:
+            payload["task_id"] = task_id
+        if difficulty:
+            payload["difficulty"] = difficulty
+        if seed is not None:
+            payload["seed"] = seed
+        data = await self._post("/reset", payload)
+        return CodeFixObservation.model_validate(data)
+
+    async def step(self, action: CodeFixAction) -> StepResult:
+        """Execute an action and return the step result."""
+        data = await self._post("/step", action.model_dump())
+        return StepResult.model_validate(data)
+
+    async def state(self) -> CodeFixState:
+        """Get internal episode state."""
+        data = await self._get("/state")
+        return CodeFixState.model_validate(data)
+
+    async def list_tasks(self, difficulty: str | None = None) -> list[dict]:
+        """List all available tasks."""
+        params = {}
+        if difficulty:
+            params["difficulty"] = difficulty
+        data = await self._get("/tasks", params=params)
+        return data
+
+    async def health(self) -> dict:
+        """Ping the server."""
+        return await self._get("/health")
+
+    # ── HTTP helpers ──────────────────────────────────────────────────────────
+
+    async def _post(self, path: str, body: dict) -> dict:
+        assert self._client, "Use `async with CodeFixClient(...) as env:`"
+        for attempt in range(self.max_retries):
+            try:
+                r = await self._client.post(path, json=body)
+                r.raise_for_status()
+                return r.json()
+            except httpx.HTTPStatusError as e:
+                logger.error(
+                    "HTTP %d on POST %s: %s", e.response.status_code, path, e.response.text
+                )
+                raise
+            except httpx.TransportError:
+                logger.error(
+                    "Transport error on POST %s (attempt %d/%d)",
+                    path,
+                    attempt + 1,
+                    self.max_retries,
+                )
+                if attempt == self.max_retries - 1:
+                    raise
+                await asyncio.sleep(0.5 * (attempt + 1))
+        raise RuntimeError(f"Failed after {self.max_retries} retries")
+
+    async def _get(self, path: str, params: dict | None = None) -> dict:
+        assert self._client, "Use `async with CodeFixClient(...) as env:`"
+        r = await self._client.get(path, params=params)
+        r.raise_for_status()
+        return r.json()
+
+    # ── Sync wrapper ──────────────────────────────────────────────────────────
+
+    def sync(self) -> SyncCodeFixClient:
+        """Return a synchronous wrapper around this async client."""
+        return SyncCodeFixClient(self)
+
+
+class SyncCodeFixClient:
+    """
+    Synchronous wrapper around CodeFixClient.
+    Runs the async client in a dedicated event loop.
+
+    Usage::
+
+        with CodeFixClient("http://localhost:8000").sync() as env:
+            obs = env.reset()
+            result = env.step(action)
+    """
+
+    def __init__(self, async_client: CodeFixClient):
+        self._async = async_client
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    def __enter__(self) -> SyncCodeFixClient:
+        self._loop = asyncio.new_event_loop()
+        self._loop.run_until_complete(self._async.__aenter__())
+        return self
+
+    def __exit__(self, *args) -> None:
+        if self._loop:
+            self._loop.run_until_complete(self._async.__aexit__(*args))
+            self._loop.close()
+
+    def _run(self, coro):
+        return self._loop.run_until_complete(coro)
+
+    def reset(self, **kwargs) -> CodeFixObservation:
+        return self._run(self._async.reset(**kwargs))
+
+    def step(self, action: CodeFixAction) -> StepResult:
+        return self._run(self._async.step(action))
+
+    def state(self) -> CodeFixState:
+        return self._run(self._async.state())
+
+    def list_tasks(self, **kwargs) -> list[dict]:
+        return self._run(self._async.list_tasks(**kwargs))