Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,99 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git wget curl && \
+    rm -rf /var/lib/apt/lists/*
+
+
+RUN wget -q https://repo1.maven.org/maven2/org/junit/platform/junit-platform-console-standalone/1.9.3/junit-platform-console-standalone-1.9.3.jar \
+-O /app/junit-platform-console-standalone.jar
+    
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=UnitTestCaseGenerator
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+
+# RUN apt-get update && apt-get install -y wget
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Java final stage mein install karo
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends default-jdk && \
+    rm -rf /var/lib/apt/lists/*
+
+# JUnit jar builder se copy karo
+COPY --from=builder /app/junit-platform-console-standalone.jar \
+     /app/junit-platform-console-standalone.jar
+ENV JUNIT_JAR=/app/junit-platform-console-standalone.jar
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+ENV ENABLE_WEB_INTERFACE=true
+ENV JAVA_HOME=/usr/lib/jvm/default-java
+ENV PATH="${JAVA_HOME}/bin:/app/.venv/bin:$PATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,282 @@
+
+
+
+# JUnit TestCase Generator
+
+An RL environment where an agent generates JUnit 5 test cases for Java code.
+
+
 ---
-title: TestCaseGenerator Env
-emoji: 👀
-colorFrom: green
-colorTo: blue
+title: Tcgenerator Environment Server
+emoji: 🖱️
+colorFrom: blue
+colorTo: gray
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Key Features
+- Executes generated tests in a sandboxed Java subprocess
+- Reward based on:
+  - Pass rate (70%)
+  - Test quantity (10%)
+  - Edge case coverage (10%)
+  - Exception handling (10%)
+
+## Tasks
+- Calculator (easy)
+- SafeMath (medium)
+- BankAccount (hard)
+
+## How it works
+1. Agent generates JUnit test code
+2. Environment compiles + runs tests
+3. Reward computed based on execution results
+
+# Tcgenerator Environment
+
+A simple test environment that echoes back messages. Perfect for testing the env APIs as well as demonstrating environment usage patterns.
+
+## Quick Start
+
+The simplest way to use the Tcgenerator environment is through the `TcgeneratorEnv` class:
+
+```python
+from tcgenerator import TcgeneratorAction, TcgeneratorEnv
+
+try:
+    # Create environment from Docker image
+    tcgeneratorenv = TcgeneratorEnv.from_docker_image("tcgenerator-env:latest")
+
+    # Reset
+    result = tcgeneratorenv.reset()
+    print(f"Reset: {result.observation.echoed_message}")
+
+    # Send multiple messages
+    messages = ["Hello, World!", "Testing echo", "Final message"]
+
+    for msg in messages:
+        result = tcgeneratorenv.step(TcgeneratorAction(message=msg))
+        print(f"Sent: '{msg}'")
+        print(f"  → Echoed: '{result.observation.echoed_message}'")
+        print(f"  → Length: {result.observation.message_length}")
+        print(f"  → Reward: {result.reward}")
+
+finally:
+    # Always clean up
+    tcgeneratorenv.close()
+```
+
+That's it! The `TcgeneratorEnv.from_docker_image()` method handles:
+- Starting the Docker container
+- Waiting for the server to be ready
+- Connecting to the environment
+- Container cleanup when you call `close()`
+
+## Building the Docker Image
+
+Before using the environment, you need to build the Docker image:
+
+```bash
+# From project root
+docker build -t tcgenerator-env:latest -f server/Dockerfile .
+```
+
+## Deploying to Hugging Face Spaces
+
+You can easily deploy your OpenEnv environment to Hugging Face Spaces using the `openenv push` command:
+
+```bash
+# From the environment directory (where openenv.yaml is located)
+openenv push
+
+# Or specify options
+openenv push --namespace my-org --private
+```
+
+The `openenv push` command will:
+1. Validate that the directory is an OpenEnv environment (checks for `openenv.yaml`)
+2. Prepare a custom build for Hugging Face Docker space (enables web interface)
+3. Upload to Hugging Face (ensuring you're logged in)
+
+### Prerequisites
+
+- Authenticate with Hugging Face: The command will prompt for login if not already authenticated
+
+### Options
+
+- `--directory`, `-d`: Directory containing the OpenEnv environment (defaults to current directory)
+- `--repo-id`, `-r`: Repository ID in format 'username/repo-name' (defaults to 'username/env-name' from openenv.yaml)
+- `--base-image`, `-b`: Base Docker image to use (overrides Dockerfile FROM)
+- `--private`: Deploy the space as private (default: public)
+
+### Examples
+
+```bash
+# Push to your personal namespace (defaults to username/env-name from openenv.yaml)
+openenv push
+
+# Push to a specific repository
+openenv push --repo-id my-org/my-env
+
+# Push with a custom base image
+openenv push --base-image ghcr.io/meta-pytorch/openenv-base:latest
+
+# Push as a private space
+openenv push --private
+
+# Combine options
+openenv push --repo-id my-org/my-env --base-image custom-base:latest --private
+```
+
+After deployment, your space will be available at:
+`https://huggingface.co/spaces/<repo-id>`
+
+The deployed space includes:
+- **Web Interface** at `/web` - Interactive UI for exploring the environment
+- **API Documentation** at `/docs` - Full OpenAPI/Swagger interface
+- **Health Check** at `/health` - Container health monitoring
+- **WebSocket** at `/ws` - Persistent session endpoint for low-latency interactions
+
+## Environment Details
+
+### Action
+**TcgeneratorAction**: Contains a single field
+- `message` (str) - The message to echo back
+
+### Observation
+**TcgeneratorObservation**: Contains the echo response and metadata
+- `echoed_message` (str) - The message echoed back
+- `message_length` (int) - Length of the message
+- `reward` (float) - Reward based on message length (length × 0.1)
+- `done` (bool) - Always False for echo environment
+- `metadata` (dict) - Additional info like step count
+
+### Reward
+The reward is calculated as: `message_length × 0.1`
+- "Hi" → reward: 0.2
+- "Hello, World!" → reward: 1.3
+- Empty message → reward: 0.0
+
+## Advanced Usage
+
+### Connecting to an Existing Server
+
+If you already have a Tcgenerator environment server running, you can connect directly:
+
+```python
+from tcgenerator import TcgeneratorEnv
+
+# Connect to existing server
+tcgeneratorenv = TcgeneratorEnv(base_url="<ENV_HTTP_URL_HERE>")
+
+# Use as normal
+result = tcgeneratorenv.reset()
+result = tcgeneratorenv.step(TcgeneratorAction(message="Hello!"))
+```
+
+Note: When connecting to an existing server, `tcgeneratorenv.close()` will NOT stop the server.
+
+### Using the Context Manager
+
+The client supports context manager usage for automatic connection management:
+
+```python
+from tcgenerator import TcgeneratorAction, TcgeneratorEnv
+
+# Connect with context manager (auto-connects and closes)
+with TcgeneratorEnv(base_url="http://localhost:8000") as env:
+    result = env.reset()
+    print(f"Reset: {result.observation.echoed_message}")
+    # Multiple steps with low latency
+    for msg in ["Hello", "World", "!"]:
+        result = env.step(TcgeneratorAction(message=msg))
+        print(f"Echoed: {result.observation.echoed_message}")
+```
+
+The client uses WebSocket connections for:
+- **Lower latency**: No HTTP connection overhead per request
+- **Persistent session**: Server maintains your environment state
+- **Efficient for episodes**: Better for many sequential steps
+
+### Concurrent WebSocket Sessions
+
+The server supports multiple concurrent WebSocket connections. To enable this,
+modify `server/app.py` to use factory mode:
+
+```python
+# In server/app.py - use factory mode for concurrent sessions
+app = create_app(
+    TcgeneratorEnvironment,  # Pass class, not instance
+    TcgeneratorAction,
+    TcgeneratorObservation,
+    max_concurrent_envs=4,  # Allow 4 concurrent sessions
+)
+```
+
+Then multiple clients can connect simultaneously:
+
+```python
+from tcgenerator import TcgeneratorAction, TcgeneratorEnv
+from concurrent.futures import ThreadPoolExecutor
+
+def run_episode(client_id: int):
+    with TcgeneratorEnv(base_url="http://localhost:8000") as env:
+        result = env.reset()
+        for i in range(10):
+            result = env.step(TcgeneratorAction(message=f"Client {client_id}, step {i}"))
+        return client_id, result.observation.message_length
+
+# Run 4 episodes concurrently
+with ThreadPoolExecutor(max_workers=4) as executor:
+    results = list(executor.map(run_episode, range(4)))
+```
+
+## Development & Testing
+
+### Direct Environment Testing
+
+Test the environment logic directly without starting the HTTP server:
+
+```bash
+# From the server directory
+python3 server/tcgenerator_environment.py
+```
+
+This verifies that:
+- Environment resets correctly
+- Step executes actions properly
+- State tracking works
+- Rewards are calculated correctly
+
+### Running Locally
+
+Run the server locally for development:
+
+```bash
+uvicorn server.app:app --reload
+```
+
+## Project Structure
+
+```
+tcgenerator/
+├── .dockerignore         # Docker build exclusions
+├── __init__.py            # Module exports
+├── README.md              # This file
+├── openenv.yaml           # OpenEnv manifest
+├── pyproject.toml         # Project metadata and dependencies
+├── uv.lock                # Locked dependencies (generated)
+├── client.py              # TcgeneratorEnv client
+├── models.py              # Action and Observation models
+└── server/
+    ├── __init__.py        # Server module exports
+    ├── tcgenerator_environment.py  # Core environment logic
+    ├── app.py             # FastAPI application (HTTP + WebSocket endpoints)
+    └── Dockerfile         # Container image definition
+```

__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Unittestcasegenerator Environment."""
+
+from .client import UnittestcasegeneratorEnv
+from .models import UnittestcasegeneratorAction, UnittestcasegeneratorObservation
+
+__all__ = [
+    "UnittestcasegeneratorAction",
+    "UnittestcasegeneratorObservation",
+    "UnittestcasegeneratorEnv",
+]

client.py

@@ -0,0 +1,99 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Unittestcasegenerator Environment Client."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import UnittestcasegeneratorAction, UnittestcasegeneratorObservation
+
+
+class UnittestcasegeneratorEnv(
+    EnvClient[UnittestcasegeneratorAction, UnittestcasegeneratorObservation, State]
+):
+    """
+    Client for the Unittestcasegenerator Environment.
+
+    This client maintains a persistent WebSocket connection to the environment server,
+    enabling efficient multi-step interactions with lower latency.
+    Each client instance has its own dedicated environment session on the server.
+
+    Example:
+        >>> # Connect to a running server
+        >>> with UnittestcasegeneratorEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.echoed_message)
+        ...
+        ...     result = client.step(UnittestcasegeneratorAction(message="Hello!"))
+        ...     print(result.observation.echoed_message)
+
+    Example with Docker:
+        >>> # Automatically start container and connect
+        >>> client = UnittestcasegeneratorEnv.from_docker_image("UnitTestCaseGenerator-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(UnittestcasegeneratorAction(message="Test"))
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: UnittestcasegeneratorAction) -> Dict:
+        """
+        Convert UnittestcasegeneratorAction to JSON payload for step message.
+
+        Args:
+            action: UnittestcasegeneratorAction instance
+
+        Returns:
+            Dictionary representation suitable for JSON encoding
+        """
+        return {
+            "message": action.message,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[UnittestcasegeneratorObservation]:
+        """
+        Parse server response into StepResult[UnittestcasegeneratorObservation].
+
+        Args:
+            payload: JSON response data from server
+
+        Returns:
+            StepResult with UnittestcasegeneratorObservation
+        """
+        obs_data = payload.get("observation", {})
+        observation = UnittestcasegeneratorObservation(
+            echoed_message=obs_data.get("echoed_message", ""),
+            message_length=obs_data.get("message_length", 0),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        """
+        Parse server response into State object.
+
+        Args:
+            payload: JSON response from state request
+
+        Returns:
+            State object with episode_id and step_count
+        """
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

inference.py

@@ -0,0 +1,182 @@
+import asyncio
+import os
+import textwrap
+from typing import List, Optional
+
+from openai import OpenAI
+
+from server.UnitTestCaseGenerator_environment import (
+    UnittestcasegeneratorEnvironment,
+    UnittestcasegeneratorAction,
+)
+
+# ── CONFIG ─────────────────────────────────────────────
+
+API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
+MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
+
+BENCHMARK = "unit_test_env"
+MAX_STEPS = 1
+SUCCESS_SCORE_THRESHOLD = 0.5
+
+DIFFICULTIES = ["easy", "medium", "hard"]
+
+# ── PROMPT ─────────────────────────────────────────────
+
+SYSTEM_PROMPT = textwrap.dedent("""
+You are an expert Java developer. You write JUnit 5 unit tests.
+
+Rules:
+- ALWAYS read the source code carefully before writing tests
+- ALWAYS use the exact class name specified in the task hint
+- NEVER write tests for a different class than what is given
+- Use @Test annotation on every test method
+- Always import: import org.junit.jupiter.api.Test;
+- Always import: import static org.junit.jupiter.api.Assertions.*;
+- Use assertEquals, assertTrue, assertFalse, assertThrows
+- Reply with ONLY Java code, no explanation
+""").strip()
+
+# ── LOGGING (STRICT FORMAT) ─────────────────────────────
+
+def log_start(task: str, env: str, model: str):
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]):
+    error_val = error if error else "null"
+    print(
+        f"[STEP] step={step} action={action[:100]} reward={reward:.2f} done={str(done).lower()} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]):
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} score={score:.2f} rewards={rewards_str}",
+        flush=True,
+    )
+
+# ── MODEL CALL ─────────────────────────────────────────────
+
+def get_tests_from_model(
+    client: OpenAI,
+    source_code: str,
+    task_hint: str,
+    feedback: Optional[str],
+) -> str:
+
+    prompt = f"""
+{task_hint}
+
+Source code:
+{source_code}
+
+Feedback: {feedback or "None"}
+
+Write JUnit 5 tests:
+"""
+
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.3,
+            max_tokens=800,
+        )
+
+        text = (completion.choices[0].message.content or "").strip()
+        return text.replace("```java", "").replace("```", "").strip()
+
+    except Exception:
+        return "public class PlaceholderTest {}"
+
+# ── MAIN ─────────────────────────────────────────────
+
+async def main():
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    from client import TcgeneratorEnv
+
+    all_rewards = []
+
+    for difficulty in DIFFICULTIES:
+        env = UnittestcasegeneratorEnvironment()
+
+        rewards: List[float] = []
+        steps_taken = 0
+        feedback = None
+
+        log_start(task=difficulty, env=BENCHMARK, model=MODEL_NAME)
+
+        try:
+            result = env.reset(difficulty=difficulty)
+
+            source_code = result.source_code
+            task_hint = result.task_hint
+
+            for step in range(1, MAX_STEPS + 1):
+                if result.done:
+                    break
+
+                action = get_tests_from_model(client, source_code, task_hint, feedback)
+
+                result = env.step(UnittestcasegeneratorAction(test_code=action))
+
+                reward = result.reward or 0.0
+                done = result.done
+                error = getattr(result, "error", None)
+
+                feedback = f"Passed {result.passed}/{result.total}"
+
+                rewards.append(reward)
+                steps_taken = step
+
+                log_step(step, action, reward, done, error)
+
+                if done:
+                    break
+
+            score = max(rewards) if rewards else 0.0
+            score = min(max(score, 0.0), 1.0)
+
+            success = score >= SUCCESS_SCORE_THRESHOLD
+
+        finally:
+            try:
+                if hasattr(env, "close"):
+                    env.close()
+            except Exception:
+                pass
+
+            log_end(success, steps_taken, score, rewards)
+
+            all_rewards.append(score)
+
+    # ── FINAL SUMMARY ─────────────────────────────
+
+    if len(all_rewards) == 3:
+        easy, medium, hard = all_rewards
+        avg = (easy + medium + hard) / 3
+
+        print("\n=== FINAL RESULT ===")
+        print(f"Model: {MODEL_NAME}")
+        print(f"Benchmark: {BENCHMARK}\n")
+
+        print(f"Easy   : {easy:.2f}")
+        print(f"Medium : {medium:.2f}")
+        print(f"Hard   : {hard:.2f}\n")
+
+        print(f"Average: {avg:.2f}")
+        print(f"Success: {'Yes' if avg >= SUCCESS_SCORE_THRESHOLD else 'No'}")
+        print("=====================")
+
+
+# ── RUN ─────────────────────────────────────────────
+
+if __name__ == "__main__":
+    asyncio.run(main())

models.py

@@ -0,0 +1,34 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for the Unittestcasegenerator Environment.
+
+The UnitTestCaseGenerator environment is a simple test environment that echoes back messages.
+"""
+from typing import Optional
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+
+
+class UnittestcasegeneratorAction(Action):
+    """Action for the Unittestcasegenerator environment - just a message to echo."""
+
+    test_code: str = Field(..., description="Java JUnit test code")
+
+
+class UnittestcasegeneratorObservation(Observation):
+    """Observation from the Unittestcasegenerator environment - the echoed message."""
+
+    source_code: str = Field(..., description="Java source code to test")
+    task_hint: str = Field(..., description="Instructions for writing tests")
+    passed: int = Field(default=0, description="Tests passed")
+    failed: int = Field(default=0, description="Tests failed")
+    total: int = Field(default=0, description="Total tests run")
+    error: Optional[str] = Field(default=None, description="Error message if any")
+    reward: float = Field(default=0.0, description="Score 0.0 to 1.0")
+    done: bool = Field(default=False, description="Episode finished?")
+    metadata: Optional[dict] = Field(default=None)

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: UnitTestCaseGenerator
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

pyproject.toml

@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-UnitTestCaseGenerator"
+version = "0.1.0"
+description = "Unittestcasegenerator environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.2",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m UnitTestCaseGenerator.server.app
+server = "UnitTestCaseGenerator.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["UnitTestCaseGenerator", "UnitTestCaseGenerator.server"]
+package-dir = { "UnitTestCaseGenerator" = ".", "UnitTestCaseGenerator.server" = "server" }

server/UnitTestCaseGenerator_environment.py

@@ -0,0 +1,458 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+"""
+Unittestcasegenerator Environment Implementation.
+
+An RL environment where an LLM agent writes JUnit 5 unit tests
+for given Java classes. Tasks range from simple pure functions
+to stateful classes requiring exception testing.
+"""
+
+import os
+import re
+import subprocess
+import shutil
+import tempfile
+import textwrap
+import json
+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
+
+try:
+    from ..models import UnittestcasegeneratorAction, UnittestcasegeneratorObservation
+except ImportError:
+    from models import UnittestcasegeneratorAction, UnittestcasegeneratorObservation
+
+
+# ─────────────────────────────────────────────
+# TASKS
+# ─────────────────────────────────────────────
+
+TASKS = {
+    "easy": {
+        "source_code": textwrap.dedent("""
+            public class Calculator {
+                public int add(int a, int b) {
+                    return a + b;
+                }
+                public boolean isPalindrome(String s) {
+                    String clean = s.toLowerCase().replace(" ", "");
+                    String reversed = new StringBuilder(clean).reverse().toString();
+                    return clean.equals(reversed);
+                }
+                public double celsiusToFahrenheit(double c) {
+                    return c * 9.0 / 5.0 + 32;
+                }
+            }
+        """).strip(),
+        "source_class": "Calculator",
+        "test_class": "CalculatorTest",
+        "task_hint": (
+            "Write JUnit 5 tests for Calculator class. "
+            "1) Class name MUST be CalculatorTest. "
+            "2) Use @Test annotation on every test method. "
+            "3) Import: import org.junit.jupiter.api.Test; "
+            "4) Import: import static org.junit.jupiter.api.Assertions.*; "
+            "5) Write at least 6 test methods. "
+            "6) Test add(), isPalindrome(), celsiusToFahrenheit(). "
+            "Reply with ONLY the Java code."
+        ),
+        "expected_min_tests": 6,
+        "requires_edge_cases": False,
+        "requires_exception": False,
+    },
+
+    "medium": {
+        "source_code": textwrap.dedent("""
+            public class SafeMath {
+                public double safeDivide(double a, double b) {
+                    if (b == 0)
+                        throw new IllegalArgumentException("Cannot divide by zero");
+                    return a / b;
+                }
+                public int getFirstElement(int[] arr) {
+                    if (arr.length == 0)
+                        throw new IndexOutOfBoundsException("Array is empty");
+                    return arr[0];
+                }
+                public int parsePositiveInt(String s) {
+                    int val = Integer.parseInt(s);
+                    if (val <= 0)
+                        throw new IllegalArgumentException("Must be positive");
+                    return val;
+                }
+            }
+        """).strip(),
+        "source_class": "SafeMath",
+        "test_class": "SafeMathTest",
+        "task_hint": (
+            "Write JUnit 5 tests for SafeMath class. "
+            "1) Class name MUST be SafeMathTest. "
+            "2) Use @Test annotation on every test method. "
+            "3) Import: import org.junit.jupiter.api.Test; "
+            "4) Import: import static org.junit.jupiter.api.Assertions.*; "
+            "5) Use assertThrows() for exception testing. "
+            "6) Test edge cases: empty array, zero, negative. "
+            "7) Write at least 8 test methods. "
+            "Reply with ONLY the Java code."
+        ),
+        "expected_min_tests": 8,
+        "requires_edge_cases": True,
+        "requires_exception": True,
+    },
+
+    "hard": {
+        "source_code": textwrap.dedent("""
+            import java.util.ArrayList;
+            import java.util.List;
+            public class BankAccount {
+                private String owner;
+                private double balance;
+                private List<String> transactions;
+                public BankAccount(String owner, double balance) {
+                    this.owner = owner;
+                    this.balance = balance;
+                    this.transactions = new ArrayList<>();
+                }
+                public double deposit(double amount) {
+                    if (amount <= 0)
+                        throw new IllegalArgumentException("Deposit must be positive");
+                    this.balance += amount;
+                    this.transactions.add("deposit:" + amount);
+                    return this.balance;
+                }
+                public double withdraw(double amount) {
+                    if (amount <= 0)
+                        throw new IllegalArgumentException("Withdrawal must be positive");
+                    if (amount > this.balance)
+                        throw new IllegalArgumentException("Insufficient funds");
+                    this.balance -= amount;
+                    this.transactions.add("withdraw:" + amount);
+                    return this.balance;
+                }
+                public int getTransactionCount() { return this.transactions.size(); }
+                public double getBalance() { return this.balance; }
+                public String getOwner() { return this.owner; }
+            }
+        """).strip(),
+        "source_class": "BankAccount",
+        "test_class": "BankAccountTest",
+        "task_hint": (
+            "Write JUnit 5 tests for BankAccount class. "
+            "1) Class name MUST be BankAccountTest. "
+            "2) Use @Test annotation on every test method. "
+            "3) Import: import org.junit.jupiter.api.Test; "
+            "4) Import: import static org.junit.jupiter.api.Assertions.*; "
+            "5) Use assertThrows() for exception testing. "
+            "6) Test deposit, withdraw, getBalance, getTransactionCount, getOwner. "
+            "7) Test exceptions: negative deposit, withdraw, insufficient funds. "
+            "8) Write at least 10 test methods. "
+            "Reply with ONLY the Java code."
+        ),
+        "expected_min_tests": 10,
+        "requires_edge_cases": True,
+        "requires_exception": True,
+    },
+}
+
+DIFFICULTIES = ("easy", "medium", "hard")
+
+
+# ─────────────────────────────────────────────
+# JAVA DETECTION
+# ─────────────────────────────────────────────
+
+def find_java():
+    for cmd in ["java", "/usr/bin/java", "/usr/local/bin/java"]:
+        try:
+            result = subprocess.run([cmd, "-version"], capture_output=True, text=True)
+            if result.returncode == 0:
+                print(json.dumps({"event": "debug", "type": "java_found", "path": cmd}), flush=True)
+                return cmd
+        except FileNotFoundError:
+            continue
+    return None
+
+
+def find_javac():
+    for cmd in ["javac", "/usr/bin/javac", "/usr/local/bin/javac"]:
+        try:
+            result = subprocess.run([cmd, "-version"], capture_output=True, text=True)
+            if result.returncode == 0:
+                print(json.dumps({"event": "debug", "type": "javac_found", "path": cmd}), flush=True)
+                return cmd
+        except FileNotFoundError:
+            continue
+    return None
+
+
+def find_junit_jar():
+    env_path = os.getenv("JUNIT_JAR")
+    if env_path and os.path.exists(env_path):
+        print(json.dumps({"event": "debug", "type": "junit_found", "path": env_path}), flush=True)
+        return env_path
+
+    candidates = [
+        "/app/junit-platform-console-standalone.jar",
+        "/app/env/junit-platform-console-standalone.jar",
+        os.path.join(os.path.dirname(__file__), "..", "junit-platform-console-standalone.jar"),
+        os.path.join(os.getcwd(), "junit-platform-console-standalone.jar"),
+        os.path.join(os.getcwd(), "libs", "junit-platform-console-standalone.jar"),
+        # "/Users/vidhikoul/Desktop/UnitTestCaseGenerator/tcgenerator/junit-platform-console-standalone.jar",
+    ]
+
+    for path in candidates:
+        abs_path = os.path.abspath(path)
+        if os.path.exists(abs_path):
+            print(json.dumps({"event": "debug", "type": "junit_found", "path": abs_path}), flush=True)
+            return abs_path
+
+    print(json.dumps({"event": "debug", "type": "junit_not_found", "tried": candidates}), flush=True)
+    return None
+
+
+# ─────────────────────────────────────────────
+# JUNIT SANDBOX
+# ─────────────────────────────────────────────
+
+def run_junit_tests(source_code: str, test_code: str,
+                    source_class: str, test_class: str,
+                    timeout: int = 30):
+
+    java  = find_java()
+    javac = find_javac()
+    junit = find_junit_jar()
+
+    if not java or not javac:
+        return 0, 0, 0, "Java not found!"
+    if not junit:
+        return 0, 0, 0, "JUnit jar not found!"
+
+    tmpdir = tempfile.mkdtemp()
+
+    try:
+        source_file = os.path.join(tmpdir, f"{source_class}.java")
+        test_file   = os.path.join(tmpdir, f"{test_class}.java")
+
+        with open(source_file, "w") as f:
+            f.write(source_code)
+        with open(test_file, "w") as f:
+            f.write(test_code)
+
+        compile_result = subprocess.run(
+            [javac, "-cp", junit, source_file, test_file],
+            capture_output=True, text=True,
+            cwd=tmpdir, timeout=30,
+        )
+
+        if compile_result.returncode != 0:
+            err = compile_result.stderr[:500]
+            print(json.dumps({"event": "debug", "type": "compile_error", "message": err[:200]}), flush=True)
+            return 0, 0, 0, f"Compile error: {err}"
+
+        run_result = subprocess.run(
+            [java, "-jar", junit, "-cp", tmpdir,
+             "--select-class", test_class, "--details", "summary"],
+            capture_output=True, text=True,
+            cwd=tmpdir, timeout=timeout,
+        )
+
+        output = run_result.stdout + run_result.stderr
+        print(json.dumps({"event": "debug", "type": "junit_output", "message": output[:300]}), flush=True)
+
+        passed, failed = parse_junit_output(output)
+        total = passed + failed
+        error = None if passed > 0 else output[-400:]
+
+        return passed, failed, total, error
+
+    except subprocess.TimeoutExpired:
+        return 0, 0, 0, "Timeout"
+    except Exception as e:
+        return 0, 0, 0, str(e)
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+
+def parse_junit_output(output: str):
+    passed = failed = 0
+
+    p = re.findall(r'(\d+)\s+tests?\s+successful', output, re.IGNORECASE)
+    if p:
+        passed = int(p[0])
+
+    f = re.findall(r'(\d+)\s+tests?\s+failed', output, re.IGNORECASE)
+    if f:
+        failed = int(f[0])
+
+    if passed == 0 and failed == 0:
+        passed = len(re.findall(r'\[\s*OK\s*\]', output))
+        failed = len(re.findall(r'\[\s*FAILED\s*\]', output))
+
+    return passed, failed
+
+
+def compute_reward(passed, total, test_code, task_cfg):
+    if total == 0:
+        return 0.0
+
+    base           = (passed / total) * 0.7
+    quantity_bonus = 0.1 if total >= task_cfg["expected_min_tests"] else 0.0
+
+    edge_bonus = 0.0
+    if task_cfg["requires_edge_cases"]:
+        edge_keywords = ["empty", "zero", "null", "negative", "0", "[]", '""']
+        if any(kw in test_code.lower() for kw in edge_keywords):
+            edge_bonus = 0.1
+
+    exception_bonus = 0.0
+    if task_cfg["requires_exception"]:
+        if "assertthrows" in test_code.lower():
+            exception_bonus = 0.1
+
+    return round(min(base + quantity_bonus + edge_bonus + exception_bonus, 1.0), 3)
+
+
+# ─────────────────────────────────────────────
+# ENVIRONMENT CLASS
+# ─────────────────────────────────────────────
+
+class UnittestcasegeneratorEnvironment(Environment):
+    """
+    JUnit Test Case Generator Environment.
+
+    An RL environment where an LLM agent learns to write JUnit 5 unit
+    tests for Java classes. The agent receives Java source code and must
+    produce test code that compiles and passes.
+
+    Difficulty levels:
+      easy:   Simple pure functions — Calculator class (6+ tests)
+      medium: Exception handling   — SafeMath class (8+ tests)
+      hard:   Stateful class       — BankAccount class (10+ tests)
+
+    Episode flow:
+      1. reset(difficulty="easy"|"medium"|"hard")
+      2. agent reads source_code + task_hint from observation
+      3. agent calls step(action) with JUnit test code
+      4. environment compiles + runs tests → returns reward (0.0–1.0)
+      5. repeat up to 6 steps or until reward >= 0.95
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        """Initialize the UnitTestCaseGenerator environment."""
+        self._state         = State(episode_id=str(uuid4()), step_count=0)
+        self._episode_count = 0
+        self._step_count    = 0
+        self._max_steps     = 6
+        self._best_reward   = 0.0
+        self._difficulty    = "easy"
+        self._task_cfg      = TASKS["easy"]
+
+    def reset(
+        self,
+        difficulty: Optional[str] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> UnittestcasegeneratorObservation:
+        """
+        Reset the environment with a new task.
+
+        Args:
+            difficulty: "easy" | "medium" | "hard"
+                        Auto-cycles easy→medium→hard if not provided.
+            episode_id: Optional custom episode ID.
+
+        Returns:
+            UnittestcasegeneratorObservation with source_code and task_hint.
+        """
+        if difficulty not in DIFFICULTIES:
+            difficulty = DIFFICULTIES[self._episode_count % 3]
+
+        self._episode_count += 1
+        self._difficulty    = difficulty
+        self._task_cfg      = TASKS[difficulty]
+        self._step_count    = 0
+        self._best_reward   = 0.0
+        self._state         = State(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0
+        )
+
+        print(json.dumps({
+            "event": "debug",
+            "type": "reset",
+            "difficulty": difficulty,
+            "source_class": self._task_cfg["source_class"],
+        }), flush=True)
+
+        return UnittestcasegeneratorObservation(
+            source_code = self._task_cfg["source_code"],
+            task_hint   = self._task_cfg["task_hint"],
+            passed=0, failed=0, total=0,
+            error=None, reward=0.0, done=False,
+            metadata={
+                "difficulty": difficulty,
+                "episode_id": self._state.episode_id,
+                "message": (
+                    f"New {difficulty} task loaded. "
+                    f"Write JUnit 5 tests for {self._task_cfg['source_class']} class."
+                ),
+            }
+        )
+
+    def step(self, action: UnittestcasegeneratorAction) -> UnittestcasegeneratorObservation:
+        """
+        Execute one step — compile and run the agent's JUnit test code.
+
+        Args:
+            action: UnittestcasegeneratorAction with test_code field.
+
+        Returns:
+            UnittestcasegeneratorObservation with passed/failed counts and reward.
+        """
+        self._state.step_count += 1
+        self._step_count += 1
+        done = self._step_count >= self._max_steps
+
+        passed, failed, total, error = run_junit_tests(
+            source_code  = self._task_cfg["source_code"],
+            test_code    = action.test_code,
+            source_class = self._task_cfg["source_class"],
+            test_class   = self._task_cfg["test_class"],
+        )
+
+        reward = compute_reward(passed, total, action.test_code, self._task_cfg)
+        self._best_reward = max(self._best_reward, reward)
+
+        if reward >= 0.95:
+            done = True
+
+        print(json.dumps({
+            "event": "debug",
+            "type": "step_result",
+            "passed": passed,
+            "failed": failed,
+            "total": total,
+            "reward": reward,
+            "done": done,
+        }), flush=True)
+
+        return UnittestcasegeneratorObservation(
+            source_code = self._task_cfg["source_code"],
+            task_hint   = self._task_cfg["task_hint"],
+            passed=passed, failed=failed, total=total,
+            error=error, reward=reward, done=done,
+        )
+
+    @property
+    def state(self) -> State:
+        """Get current episode state."""
+        return self._state

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Unittestcasegenerator environment server components."""
+
+from .UnitTestCaseGenerator_environment import UnittestcasegeneratorEnvironment
+
+__all__ = ["UnittestcasegeneratorEnvironment"]

server/app.py

@@ -0,0 +1,84 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Unittestcasegenerator Environment.
+
+This module creates an HTTP server that exposes the UnittestcasegeneratorEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+try:
+    from models import UnittestcasegeneratorAction, UnittestcasegeneratorObservation
+    from .UnitTestCaseGenerator_environment import UnittestcasegeneratorEnvironment
+except ModuleNotFoundError:
+    from models import UnittestcasegeneratorAction, UnittestcasegeneratorObservation
+    from server.UnitTestCaseGenerator_environment import UnittestcasegeneratorEnvironment
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    UnittestcasegeneratorEnvironment,
+    UnittestcasegeneratorAction,
+    UnittestcasegeneratorObservation,
+    env_name="UnitTestCaseGenerator",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m UnitTestCaseGenerator.server.app
+
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn UnitTestCaseGenerator.server.app:app --workers 4
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(port=args.port)

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+