Upload folder using huggingface_hub

Dockerfile

@@ -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.
+
+# 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 && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=constraint_env
+
+# 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 --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
+
+# 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'
+
+# HF Spaces uses port 7860 by default; override with PORT env var for local use
+ENV PORT=7860
+
+# Health check (uses the PORT variable)
+HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \
+    CMD curl -f http://localhost:${PORT}/health || exit 1
+
+# Run the FastAPI server – respects $PORT so it works on HF Spaces and locally
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port ${PORT:-7860}"]

README.md

@@ -1,10 +1,62 @@
----
-title: Constraint Env
-emoji: 🏢
-colorFrom: gray
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Constraint Environment
+emoji: 🧩
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+license: mit
+short_description: RL training env — natural language to constraint AST
+base_path: /web
+---
+
+# Constraint Environment
+
+
+An environment to convert to DSL from natural language
+
+
+
+## Development & Testing
+
+### Direct Environment Testing
+
+Test the environment logic directly without starting the HTTP server:
+
+```bash
+# From the server directory
+python3 server/constraint_env_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
+
+```
+constraint_env/
+├── .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              # ConstraintEnv client
+├── models.py              # Action and Observation models
+└── server/
+    ├── __init__.py        # Server module exports
+    ├── constraint_env_environment.py  # Core environment logic
+    ├── app.py             # FastAPI application (HTTP + WebSocket endpoints)
+    └── Dockerfile         # Container image definition
+```

__init__.py

@@ -0,0 +1,10 @@
+"""Constraint Env Environment."""
+
+from .client import ConstraintEnv
+from .models import ConstraintAction, ConstraintObservation
+
+__all__ = [
+    "ConstraintAction",
+    "ConstraintObservation",
+    "ConstraintEnv",
+]

client.py

@@ -0,0 +1,80 @@
+# 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.
+
+"""Constraint Env 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 ConstraintAction, ConstraintObservation, ConstraintState
+
+
+class ConstraintEnv(
+    EnvClient[ConstraintAction, ConstraintObservation, ConstraintState]
+):
+    """
+    Client for the Constraint Env 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.
+
+    """
+
+    def _step_payload(self, action: ConstraintAction) -> Dict:
+        """
+        Convert ConstraintAction to JSON payload for step message.
+
+        Args:
+            action: ConstraintAction instance
+
+        Returns:
+            Dictionary representation suitable for JSON encoding
+        """
+        return {
+            "ast_output": action.ast_output,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[ConstraintObservation]:
+        """
+        Parse server response into StepResult[ConstraintObservation].
+
+        Args:
+            payload: JSON response data from server
+
+        Returns:
+            StepResult with ConstraintObservation
+        """
+        obs_data = payload.get("observation", {})
+        observation = ConstraintObservation(
+            prompt=obs_data.get("prompt", ""),
+            info=obs_data.get("info", 0),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> ConstraintState:
+        """
+        Parse server response into State object.
+
+        Args:
+            payload: JSON response from state request
+
+        Returns:
+            State object with episode_id and step_count
+        """
+        return ConstraintState(
+            episode_id=payload.get("episode_id"),
+        )

dataset_example.py

@@ -0,0 +1,133 @@
+# 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.
+
+"""
+Dataset for the Constraint Environment.
+
+Three difficulty tiers (easy / medium / hard) with increasing structural
+complexity for translating natural-language scheduling constraints into a
+JSON-based AST DSL.
+"""
+
+dataset = {
+    # ------------------------------------------------------------------
+    # EASY – single quantifier, no WHERE clause, direct assert
+    # ------------------------------------------------------------------
+    "easy": [
+        {
+            "prompt": (
+                "No classes should be scheduled on Saturday."
+            ),
+            "target_ast": {
+                "type": "hard",
+                "name": "no_saturday_classes",
+                "forall": [
+                    {"var": "b", "domain": "branches"},
+                    {"var": "sub", "domain": "subjects"},
+                    {"var": "d", "domain": "days"},
+                    {"var": "s", "domain": "slots"},
+                ],
+                "where": "d == 5",
+                "assert": "schedule(b, sub, d, s) == 0",
+            },
+        },
+        {
+            "prompt": (
+                "Every teacher must teach at least one subject."
+            ),
+            "target_ast": {
+                "type": "soft",
+                "name": "teacher_teaches_one",
+                "forall": [
+                    {"var": "t", "domain": "teachers"},
+                ],
+                "assert": "SUM(teaches(t, sub)) >= 1",
+            },
+        },
+    ],
+
+    # ------------------------------------------------------------------
+    # MEDIUM – two quantifiers, WHERE clause, combined assert
+    # ------------------------------------------------------------------
+    "medium": [
+        {
+            "prompt": (
+                "No non-online classes should be scheduled on Saturday."
+            ),
+            "target_ast": {
+                "type": "hard",
+                "name": "no_non_online_saturday",
+                "forall": [
+                    {"var": "b", "domain": "branches"},
+                    {"var": "sub", "domain": "subjects"},
+                    {"var": "d", "domain": "days"},
+                    {"var": "s", "domain": "slots"},
+                ],
+                "where": "subject_type(b, sub) != 'online' AND d == 5",
+                "assert": "schedule(b, sub, d, s) == 0",
+            },
+        },
+        {
+            "prompt": (
+                "A teacher cannot be assigned to two different slots at the same time."
+            ),
+            "target_ast": {
+                "type": "hard",
+                "name": "no_teacher_time_conflict",
+                "forall": [
+                    {"var": "t", "domain": "teachers"},
+                    {"var": "d", "domain": "days"},
+                    {"var": "s", "domain": "slots"},
+                ],
+                "assert": "COUNT(occupies_teacher(t, d, s)) <= 1",
+            },
+        },
+    ],
+
+    # ------------------------------------------------------------------
+    # HARD – multiple quantifiers, nested WHERE + AND/OR, minimize
+    # ------------------------------------------------------------------
+    "hard": [
+        {
+            "prompt": (
+                "Minimize the number of occupied slots for each branch on any given day, "
+                "but only for subjects that are labelled as practical."
+            ),
+            "target_ast": {
+                "type": "soft",
+                "name": "minimize_practical_slots",
+                "forall": [
+                    {"var": "b", "domain": "branches"},
+                    {"var": "sub", "domain": "subjects"},
+                    {"var": "d", "domain": "days"},
+                    {"var": "s", "domain": "slots"},
+                ],
+                "where": "subject_type(b, sub) == 'practical'",
+                "minimize": "SUM(occupies(b, sub, d, s))",
+            },
+        },
+        {
+            "prompt": (
+                "No branch may have more than four scheduled slots in a single day, "
+                "unless a subject is online, in which case it may occupy one extra slot."
+            ),
+            "target_ast": {
+                "type": "hard",
+                "name": "daily_slot_cap",
+                "forall": [
+                    {"var": "b", "domain": "branches"},
+                    {"var": "d", "domain": "days"},
+                    {"var": "sub", "domain": "subjects"},
+                    {"var": "s", "domain": "slots"},
+                ],
+                "assert": (
+                    "SUM(schedule(b, sub, d, s)) <= 4 OR "
+                    "(subject_type(b, sub) == 'online' AND SUM(schedule(b, sub, d, s)) <= 5)"
+                ),
+            },
+        },
+    ],
+}

guidelines.txt

@@ -0,0 +1,150 @@
+🚀 Hackathon Submission Guidelines (OpenEnv RL Challenge)
+1. Project Structure
+* Your inference script must be named inference.py
+* It must be located in the root directory of your project
+
+________________
+
+
+2. LLM Usage Requirements
+   * You must use the OpenAI Client for all LLM calls
+   * Do not use alternative SDKs or direct HTTP calls
+
+________________
+
+
+3. Required Environment Variables
+Your inference.py must read the following environment variables:
+      * API_BASE_URL
+      * Description: API endpoint for the LLM
+      * Requirement: Must include a default value
+      * MODEL_NAME
+      * Description: Model identifier used for inference
+      * Requirement: Must include a default value
+      * HF_TOKEN
+      * Description: Hugging Face API token
+      * Requirement: Mandatory (no default required)
+
+
+4. INFERENCE OUTPUT FORMAT
+The script must emit exactly three line types to stdout, in this order:
+    [START] task=<task_name> env=<benchmark> model=<model_name>
+    [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
+    [END]   success=<true|false> steps=<n> rewards=<r1,r2,...,rn>
+
+
+
+
+
+
+  Rules:
+    - One [START] line at episode begin.
+    - One [STEP] line per step, immediately after env.step() returns.
+    - One [END] line after env.close(), always emitted (even on exception).
+    - reward and rewards are formatted to 2 decimal places.
+    - done and success are lowercase booleans: true or false.
+    - error is the raw last_action_error string, or null if none.
+    - All fields on a single line with no newlines within a line.
+  Example:
+    [START] task=click-test env=miniwob model=Qwen3-VL-30B
+    [STEP] step=1 action=click('123') reward=0.00 done=false error=null
+    [STEP] step=2 action=fill('456','text') reward=0.00 done=false error=null
+    [STEP] step=3 action=click('789') reward=1.00 done=true error=null
+    [END] success=true steps=3 rewards=0.00,0.00,1.00
+✅ Example (inference.py)
+import os
+from openai import OpenAI
+
+
+# Read environment variables with defaults where required
+API_BASE_URL = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4.1-mini")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+
+if HF_TOKEN is None:
+    raise ValueError("HF_TOKEN environment variable is required")
+
+
+# Initialize OpenAI client
+client = OpenAI(
+    base_url=API_BASE_URL,
+    api_key=HF_TOKEN
+)
+
+
+def run_inference(prompt: str):
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+    response = response.choices[0].message.content
+    # Print output based on above given format
+
+
+
+
+if __name__ == "__main__":
+    print(run_inference("Hello from OpenEnv!"))
+
+________________
+4. Hugging Face Space Guidelines
+      * Building a Hugging Face Space can take significant time, especially if multiple spaces are active
+      * To avoid delays:
+      * Turn off all unnecessary spaces
+      * Keep only your primary submission space running
+________________
+
+
+5. Submission Validation Rules
+      * The system will check if your Hugging Face Space is live
+      * If your space is not in a running state, your submission will fail automatically
+Before submitting:
+      * Ensure your space is fully built
+      * Confirm it is in the “Running” state
+________________
+
+
+6. Hardware Requirements
+      * Your solution will be executed inside a Docker container with limited resources
+      * It must run within the following constraints:
+      * 2 vCPU
+      * 8 GB RAM
+👉 Ensure your model, dependencies, and runtime fit within these limits. Submissions exceeding these constraints may fail during evaluation.
+________________
+
+
+6. Resubmissions
+      * You are allowed to resubmit your project multiple times
+      * If your submission fails validation, you can:
+      * Fix the issues
+      * Ensure your Hugging Face Space is running
+      * Submit again
+👉 There is no penalty for resubmitting, so iterate until your submission passes all checks.
+________________
+
+
+⚠️ Common Failure Cases (Avoid These)
+      * inference.py not in root directory
+      * Missing default values for API_BASE_URL or MODEL_NAME
+      * Missing HF_TOKEN
+      * Hugging Face Space still building during submission
+      * Space stopped due to multiple active deployments
+________________
+
+
+🚀  Reference projects to guide you
+Here are some strong examples from the San Francisco edition to help you understand how to structure your environment:
+      * Calendar Environment Server
+https://github.com/meta-pytorch/OpenEnv/tree/main/envs/calendar_env
+      * Reasoning Gym Environment Server
+https://github.com/meta-pytorch/OpenEnv/tree/main/envs/reasoning_gym_env
+      * TB2 Environment Server
+https://github.com/meta-pytorch/OpenEnv/tree/main/envs/tbench2_env
+      * CARLA Environment Server
+https://github.com/meta-pytorch/OpenEnv/tree/main/envs/carla_env
+      * REPL Environment Server
+https://github.com/meta-pytorch/OpenEnv/tree/main/envs/repl_env
+Use these as direction, not as templates. Focus on understanding structure and approach.

inference.py

@@ -0,0 +1,282 @@
+"""
+inference.py – Baseline evaluator for the Constraint Environment.
+
+Reads environment variables:
+  API_BASE_URL  – LLM endpoint  (default: https://openrouter.ai/api/v1)
+  MODEL_NAME    – Model id       (default: openai/gpt-oss-120b)
+  HF_TOKEN      – API key        (REQUIRED – raises ValueError if missing)
+
+Output format (stdout only):
+  [START] task=<task_name> env=constraint_env model=<model_name>
+  [STEP]  step=<n> action=<ast_json> reward=<0.00> done=<true|false> error=<msg|null>
+  [END]   success=<true|false> steps=<n> rewards=<r1,r2,...>
+"""
+
+import os
+import sys
+import json
+import asyncio
+
+from openai import OpenAI
+import dotenv
+dotenv.load_dotenv()
+# ---------------------------------------------------------------------------
+# Environment variables
+# ---------------------------------------------------------------------------
+
+API_BASE_URL: str = os.getenv("API_BASE_URL", "https://openrouter.ai/api/v1")
+MODEL_NAME:   str = os.getenv("MODEL_NAME",   "openai/gpt-oss-120b")
+HF_TOKEN:     str | None = os.getenv("HF_TOKEN")
+
+if HF_TOKEN is None:
+    raise ValueError(
+        "HF_TOKEN environment variable is required. "
+        "Export it before running:\n"
+        '  $env:HF_TOKEN="sk-or-v1-..."   (PowerShell)\n'
+        '  export HF_TOKEN="sk-or-v1-..."  (bash)'
+    )
+
+# ---------------------------------------------------------------------------
+# OpenAI client (routed through OpenRouter by default)
+# ---------------------------------------------------------------------------
+
+_llm = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+
+# ---------------------------------------------------------------------------
+# System prompt shared across all tasks
+# ---------------------------------------------------------------------------
+
+_SYSTEM_PROMPT = """\
+You are an expert constraint compiler for a university scheduling system.
+Your job is to convert a natural-language scheduling constraint into a JSON AST \
+(Abstract Syntax Tree) that precisely captures the logical structure of the rule.
+
+════════════════════════════════════════
+SCHEMA
+════════════════════════════════════════
+{
+  "type":    "hard" | "soft",        // hard = must not be violated; soft = penalised if violated
+  "name":    "<snake_case_identifier>",
+  "forall":  [                        // quantifiers – declare every variable you use
+    {"var": "<letter>", "domain": "<domain>"},
+    ...
+  ],
+  "where":   "<expression>",          // OPTIONAL filter / guard condition
+  "assert":  "<expression>"           // the constraint body  (use XOR with "minimize")
+  // OR
+  "minimize": "<expression>"          // objective to minimise (use XOR with "assert")
+}
+
+════════════════════════════════════════
+VALID DOMAINS
+════════════════════════════════════════
+  teachers · subjects · branches · days · slots
+
+════════════════════════════════════════
+VALID FUNCTIONS  (arity shown)
+════════════════════════════════════════
+  subject_type(branch, subject)            → 2 args   returns 'online'|'practical'|...
+  schedule(branch, subject, day, slot)     → 4 args   returns 0 or 1
+  occupies(branch, subject, day, slot)     → 4 args   returns 0 or 1
+  occupies_teacher(teacher, day, slot)     → 3 args   returns 0 or 1
+  teaches(teacher, subject)               → 2 args   returns 0 or 1
+  SUM(expr)                               → 1 arg    aggregate sum
+  COUNT(expr)                             → 1 arg    aggregate count
+
+════════════════════════════════════════
+OPERATORS
+════════════════════════════════════════
+  Logical : AND  OR  NOT  IN
+  Compare : ==  !=  <=  >=  <  >
+
+Days are 0-indexed integers  (Monday = 0 … Saturday = 5).
+
+════════════════════════════════════════
+RULES
+════════════════════════════════════════
+• Every variable referenced in "where", "assert", or "minimize" MUST be declared in "forall".
+• "where" acts as a guard – only pairs/tuples satisfying it are considered.
+• Use "hard" for absolute rules and "soft" for optimisation objectives.
+• Nested calls like SUM(schedule(b, sub, d, s)) are allowed.
+
+════════════════════════════════════════
+EXAMPLE
+═��══════════════════════════════════════
+INPUT:
+  "There should not be any classes on saturday, except online classes."
+
+OUTPUT:
+{
+  "type": "hard",
+  "name": "no_non_online_saturday",
+  "forall": [
+    {"var": "b",   "domain": "branches"},
+    {"var": "sub", "domain": "subjects"},
+    {"var": "d",   "domain": "days"},
+    {"var": "s",   "domain": "slots"}
+  ],
+  "where":  "subject_type(b, sub) != 'online' AND d == 5",
+  "assert": "schedule(b, sub, d, s) == 0"
+}
+
+EXPLANATION:
+• type="hard"   – absolute rule, no violation allowed.
+• forall        – all four variables appear in the expressions, so all four are declared.
+• where         – guard: only consider rows where the subject is NOT online AND the day is Saturday (index 5).
+• assert        – for every qualifying (b, sub, d, s) tuple, the schedule slot must be 0 (i.e., no class).
+
+════════════════════════════════════════
+Return ONLY the raw JSON object.
+Do NOT wrap in markdown fences. Do NOT add any explanation outside the JSON.
+Every key/value must appear on a single line in the final output if possible.
+"""
+
+
+# ---------------------------------------------------------------------------
+# LLM call
+# ---------------------------------------------------------------------------
+
+def _call_llm(prompt: str) -> str:
+    """Call the LLM and return the raw text content."""
+    response = _llm.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": _SYSTEM_PROMPT},
+            {"role": "user",   "content": prompt},
+        ],
+        temperature=0.0,
+    )
+    return response.choices[0].message.content or ""
+
+
+# ---------------------------------------------------------------------------
+# Single-task evaluation (synchronous, one step per task)
+# ---------------------------------------------------------------------------
+
+def _run_task(task_id: str, env_url: str = "http://localhost:8000") -> None:
+    """
+    Run one episode for the given difficulty task.
+
+    Uses the ConstraintEnv WebSocket client to interact with the live server,
+    then prints [START], one [STEP], and [END] to stdout.
+    """
+    try:
+        from client import ConstraintEnv
+    except ImportError:
+        from constraint_env.client import ConstraintEnv  # type: ignore
+
+    try:
+        from models import ConstraintAction
+    except ImportError:
+        from constraint_env.models import ConstraintAction  # type: ignore
+
+    rewards: list[float] = []
+    step_count  = 0
+    last_error  = None
+    success     = False
+
+    # ------------------------------------------------------------------
+    async def _run():
+        nonlocal step_count, last_error, success
+
+        async with ConstraintEnv(
+            env_url,
+            connect_timeout_s=30.0,
+            message_timeout_s=120.0,
+        ) as env:
+            # Reset with the requested difficulty
+            obs = await env.reset(task_id=task_id)
+
+            _emit_start(task_id)
+
+            prompt_text = obs.observation.prompt
+
+            # Generate AST from LLM
+            raw_output = _call_llm(prompt_text)
+
+            # Sanitise: strip markdown fences if present
+            raw_output = raw_output.strip()
+            if raw_output.startswith("```"):
+                raw_output = raw_output.split("\n", 1)[-1]
+                raw_output = raw_output.rsplit("```", 1)[0].strip()
+
+            # Compact the JSON to a single line (rule: no newlines inside [STEP])
+            try:
+                action_str = json.dumps(json.loads(raw_output), separators=(",", ":"))
+            except (json.JSONDecodeError, TypeError):
+                action_str = raw_output.replace("\n", " ").replace("\r", "")
+
+            action      = ConstraintAction(ast_output=action_str)
+            step_result = await env.step(action)
+
+            step_count  = 1
+            reward      = float(step_result.reward or 0.0)
+            done        = bool(step_result.done)
+            last_error  = step_result.observation.info.get("error") if step_result.observation else None
+            rewards.append(reward)
+
+            _emit_step(step_count, action_str, reward, done, last_error)
+
+            success = (reward >= (_W_JSON + _W_STRUCTURE)) if done else False
+
+    asyncio.run(_run())
+    _emit_end(success, step_count, rewards)
+
+
+# ---------------------------------------------------------------------------
+# Reward weights (mirrored from environment for success threshold)
+# ---------------------------------------------------------------------------
+
+_W_JSON      = 1 / 8
+_W_STRUCTURE = 2 / 8
+
+
+# ---------------------------------------------------------------------------
+# Stdout emitters – the ONLY things that print to stdout
+# ---------------------------------------------------------------------------
+
+def _emit_start(task_id: str) -> None:
+    print(f"[START] task={task_id} env=constraint_env model={MODEL_NAME}", flush=True)
+
+
+def _emit_step(
+    step: int,
+    action: str,
+    reward: float,
+    done: bool,
+    error: str | None,
+) -> None:
+    done_str  = "true" if done  else "false"
+    error_str = error  if error else "null"
+    # Ensure action has no newlines (single line rule)
+    action_safe = action.replace("\n", " ").replace("\r", "")
+    print(
+        f"[STEP] step={step} action={action_safe} "
+        f"reward={reward:.2f} done={done_str} error={error_str}",
+        flush=True,
+    )
+
+
+def _emit_end(success: bool, steps: int, rewards: list[float]) -> None:
+    success_str  = "true" if success else "false"
+    rewards_str  = ",".join(f"{r:.2f}" for r in rewards) if rewards else "0.00"
+    print(
+        f"[END] success={success_str} steps={steps} rewards={rewards_str}",
+        flush=True,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    SERVER_URL = os.getenv("ENV_SERVER_URL", "http://localhost:8000")
+
+    for difficulty in ("easy", "medium", "hard"):
+        try:
+            _run_task(task_id=difficulty, env_url=SERVER_URL)
+        except Exception as exc:
+            # Guarantee [END] is always emitted even on failure
+            _emit_end(success=False, steps=0, rewards=[])
+            print(f"# ERROR during {difficulty}: {exc}", file=sys.stderr, flush=True)

models.py

@@ -0,0 +1,38 @@
+# 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 Constraint Env Environment.
+
+The constraint_env environment is a simple test environment that echoes back messages.
+"""
+
+from openenv.core.env_server.types import Action, Observation, State
+from typing import Dict, Any, Optional
+
+
+class ConstraintAction(Action):
+    """Output as AST by LLM."""
+
+    ast_output: str
+
+
+class ConstraintObservation(Observation):
+    """Observation from the environment, user prompt and rewards"""
+
+    prompt: str
+    done: bool
+    reward: float
+    info: Dict[str, Any]
+
+
+class ConstraintState(State):
+    """Current state from the environment"""
+    episode_id: Optional[str] = None
+
+
+
+

openenv.yaml

@@ -0,0 +1,25 @@
+spec_version: 1
+name: constraint_env
+description: >
+  Natural-language to constraint-AST translation environment for RL training.
+  Agents translate scheduling constraints written in plain English into a
+  structured JSON DSL (Abstract Syntax Tree).
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+tasks:
+  - id: easy
+    description: Single quantifier, direct assert, no WHERE clause
+    difficulty: easy
+  - id: medium
+    description: Two quantifiers with a WHERE filter clause and combined assert
+    difficulty: medium
+  - id: hard
+    description: Multiple quantifiers, nested WHERE with AND/OR, minimize objective
+    difficulty: hard
+tags:
+  - openenv
+  - scheduling
+  - nlp-to-dsl
+  - constraint-satisfaction

openenv_constraint_env.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: openenv-constraint_env
+Version: 0.1.0
+Summary: Constraint Env environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: openenv-core[core]>=0.2.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_constraint_env.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+__init__.py
+client.py
+dataset_example.py
+inference.py
+models.py
+pyproject.toml
+./__init__.py
+./client.py
+./dataset_example.py
+./inference.py
+./models.py
+openenv_constraint_env.egg-info/PKG-INFO
+openenv_constraint_env.egg-info/SOURCES.txt
+openenv_constraint_env.egg-info/dependency_links.txt
+openenv_constraint_env.egg-info/entry_points.txt
+openenv_constraint_env.egg-info/requires.txt
+openenv_constraint_env.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/constraint_env_environment.py

openenv_constraint_env.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_constraint_env.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = constraint_env.server.app:main

openenv_constraint_env.egg-info/requires.txt

@@ -0,0 +1,6 @@
+dotenv>=0.9.9
+openenv-core[core]>=0.2.2
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_constraint_env.egg-info/top_level.txt

@@ -0,0 +1 @@
+constraint_env

problem_statement.txt

@@ -0,0 +1,64 @@
+Functional Requirements
+1. Real-World Task Simulation
+The environment must represent tasks that humans actually perform in real settings—no games or toy problems.
+Examples include email triage, code review, data cleaning, scheduling, customer support, and content moderation.
+________________
+
+
+2. OpenEnv Specification Compliance
+The environment must fully implement the OpenEnv interface, including:
+* Typed Observation, Action, and Reward models using Pydantic
+* step(action) → returns (observation, reward, done, info)
+* reset() → returns the initial observation
+* state() → returns the current state
+* An openenv.yaml file containing metadata
+The implementation must successfully pass validation via openenv validate.
+________________
+
+
+3. Minimum of Three Tasks with Agent Graders
+* Provide at least three tasks, each with a clearly defined objective
+* Tasks should span increasing difficulty: easy → medium → hard
+* Each task must include a programmatic grader that assigns a score between 0.0 and 1.0
+* Grading criteria must be clear, deterministic, and reproducible
+________________
+
+
+4. Meaningful Reward Function
+* The reward function must provide feedback throughout the task trajectory, not just at completion
+* It should reward incremental progress toward the objective
+* It must penalize undesirable behaviors such as infinite loops or destructive actions
+________________
+
+
+5. Baseline Inference Script
+* Include an inference script that uses the OpenAI API client to evaluate a model within the environment
+* API credentials must be read from environment variables (HF_TOKEN)
+* The script should produce a reproducible baseline score across all tasks
+________________
+
+
+Non-Functional Requirements
+1. Deployment on Hugging Face Spaces
+* The environment must be deployable as a containerized Hugging Face Space
+* It should be tagged with openenv
+________________
+
+
+2. Containerized Execution
+* Provide a working Dockerfile
+* The environment must build and run successfully using:
+   * docker build
+   * docker run
+________________
+
+
+3. Documentation
+The README must include:
+* Environment overview and motivation
+* Definitions of action and observation spaces
+* Task descriptions with expected difficulty levels
+* Setup and usage instructions
+* Baseline performance scores
+
+Additional Guideline: Meta OpenEnv Hackathon: Guidelines

pyproject.toml

@@ -0,0 +1,46 @@
+# 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-constraint_env"
+version = "0.1.0"
+description = "Constraint Env environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    "dotenv>=0.9.9",
+    # 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 constraint_env.server.app
+server = "constraint_env.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["constraint_env", "constraint_env.server"]
+package-dir = { "constraint_env" = ".", "constraint_env.server" = "server" }

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.
+
+"""Constraint Env environment server components."""
+
+from .constraint_env_environment import ConstraintEnvironment
+
+__all__ = ["ConstraintEnvironment"]

server/app.py

@@ -0,0 +1,126 @@
+# 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 Constraint Env Environment.
+
+This module creates an HTTP server that exposes the ConstraintEnvironment
+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 ConstraintAction, ConstraintObservation
+    from .constraint_env_environment import ConstraintEnvironment
+except ImportError:
+    from constraint_env.models import ConstraintAction, ConstraintObservation
+    from constraint_env.server.constraint_env_environment import ConstraintEnvironment
+
+# Load the dataset so the environment can be initialised without crashing.
+try:
+    from dataset_example import dataset as _DATASET
+except ImportError:
+    from constraint_env.dataset_example import dataset as _DATASET  # type: ignore
+
+
+def _make_env():
+    """Factory that passes the pre-loaded dataset into ConstraintEnvironment."""
+    return ConstraintEnvironment(dataset=_DATASET)
+
+
+# Create the app – pass the factory so create_app calls _make_env() per session.
+app = create_app(
+    _make_env,
+    ConstraintAction,
+    ConstraintObservation,
+    env_name="constraint_env",
+    max_concurrent_envs=1,
+)
+
+
+# ---------------------------------------------------------------------------
+# PWA manifest – browsers request this at root level for the web UI
+# ---------------------------------------------------------------------------
+
+from fastapi.responses import JSONResponse  # noqa: E402
+
+
+@app.get("/manifest.json", include_in_schema=False)
+async def web_manifest():
+    return JSONResponse(
+        content={
+            "name": "Constraint Environment",
+            "short_name": "ConstraintEnv",
+            "description": "RL training environment: natural-language → constraint AST",
+            "start_url": "/web/",
+            "display": "standalone",
+            "background_color": "#1e1e2e",
+            "theme_color": "#7c3aed",
+            "icons": [
+                {
+                    "src": "https://huggingface.co/front/assets/huggingface_logo-noborder.svg",
+                    "sizes": "any",
+                    "type": "image/svg+xml",
+                }
+            ],
+        },
+        headers={"Cache-Control": "public, max-age=3600"},
+    )
+
+
+def main(host: str = "localhost", 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 constraint_env.server.app
+
+    Args:
+        host: Host address to bind to (default: "localhost")
+        port: Port number to listen on (default: 8000)
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn constraint_env.server.app:app --workers 4
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Constraint Env FastAPI Server")
+    parser.add_argument("--host", type=str, default="localhost")
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(host=args.host, port=args.port)

server/constraint_env_environment.py

@@ -0,0 +1,390 @@
+# 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.
+
+"""
+Constraint Env Environment Implementation.
+
+Evaluates an LLM's ability to convert natural-language scheduling
+constraints into a JSON AST DSL.
+
+Reward breakdown per step:
+  +0.125  valid JSON                      (1 / 8 of max)
+  +0.250  correct top-level structure     (2 / 8 of max)
+  +0.625  exact match with target AST     (5 / 8 of max)
+  ──────
+  1.000   total maximum reward
+
+Penalties:
+  -0.250  bad_structure (structure wrong but JSON parsed)
+  -0.250  invalid_json  (cannot parse at all, replaces reward=0)
+"""
+
+import re
+import json
+from uuid import uuid4
+from typing import Any, Dict, List, Optional
+
+from openenv.core.env_server.interfaces import Environment
+
+try:
+    from ..models import ConstraintAction, ConstraintObservation, ConstraintState
+except ImportError:
+    from models import ConstraintAction, ConstraintObservation, ConstraintState
+
+
+# ---------------------------------------------------------------------------
+# Domain knowledge
+# ---------------------------------------------------------------------------
+
+VALID_DOMAINS = {"teachers", "subjects", "branches", "days", "slots"}
+
+VALID_FUNCTIONS: Dict[str, int] = {
+    "subject_type": 2,
+    "schedule": 4,
+    "occupies": 4,
+    "occupies_teacher": 3,
+    "teaches": 2,
+    "SUM": 1,
+    "COUNT": 1,
+}
+
+# Reward weights (must sum to 1.0)
+_W_JSON      = 1 / 8   # 0.125
+_W_STRUCTURE = 2 / 8   # 0.250
+_W_MATCH     = 5 / 8   # 0.625
+_PENALTY_BAD_STRUCTURE = -0.250
+_PENALTY_INVALID_JSON  = -0.250
+
+
+# ---------------------------------------------------------------------------
+# Environment
+# ---------------------------------------------------------------------------
+
+class ConstraintEnvironment(Environment):
+    """
+    OpenEnv environment for natural-language → constraint-AST translation.
+
+    Args:
+        dataset: Dict with keys "easy", "medium", "hard", each a list of
+                 {"prompt": str, "target_ast": dict} entries.
+                 If omitted, the built-in dataset_example is used.
+    """
+
+    def __init__(self, dataset: Optional[Dict[str, List[Dict]]] = None):
+        if dataset is None:
+            try:
+                from dataset_example import dataset as _ds
+            except ImportError:
+                from constraint_env.dataset_example import dataset as _ds  # type: ignore
+            dataset = _ds
+
+        self._dataset = dataset
+        self._difficulty: str = "easy"
+        self._indexes: Dict[str, int] = {k: 0 for k in dataset}
+        self._current_sample: Optional[Dict] = None
+        self._state = ConstraintState(episode_id=None)
+
+    # ------------------------------------------------------------------
+    # OpenEnv interface
+    # ------------------------------------------------------------------
+
+    def reset(self, task_id: Optional[str] = None):
+        """
+        Reset the environment for a new episode.
+
+        Args:
+            task_id: One of "easy", "medium", or "hard".
+                     Defaults to cycling through "easy".
+        """
+        if task_id and task_id in self._dataset:
+            self._difficulty = task_id
+        elif task_id is None:
+            # Default: cycle through easy samples
+            self._difficulty = "easy"
+
+        pool = self._dataset[self._difficulty]
+        idx  = self._indexes[self._difficulty]
+        self._current_sample = pool[idx]
+        self._indexes[self._difficulty] = (idx + 1) % len(pool)
+        self._state = ConstraintState(episode_id=str(uuid4()))
+
+        return ConstraintObservation(
+            prompt=self._current_sample["prompt"],
+            done=False,
+            reward=0.0,
+            info={"difficulty": self._difficulty},
+        )
+
+    def step(self, action: ConstraintAction):
+        """
+        Evaluate the agent's AST output and return a scored observation.
+        Reward is normalised to [−0.25, 1.0].
+        """
+        reward = 0.0
+        info: Dict[str, Any] = {"difficulty": self._difficulty}
+
+        # ── 1. Parse JSON ────────────────────────────────────────────
+        try:
+            ast = json.loads(action.ast_output)
+            reward += _W_JSON
+        except (json.JSONDecodeError, TypeError):
+            reward += _PENALTY_INVALID_JSON
+            return ConstraintObservation(
+                prompt=self._current_sample["prompt"],
+                done=True,
+                reward=round(reward, 4),
+                info={**info, "error": "invalid_json"},
+            )
+
+        # ── 2. Validate structure ─────────────────────────────────────
+        if self._validate_structure(ast):
+            reward += _W_STRUCTURE
+        else:
+            reward += _PENALTY_BAD_STRUCTURE
+            info["error"] = "bad_structure"
+
+        # ── 3. Logic match (ignores "name" – user-chosen identifier) ──────
+        if "target_ast" in self._current_sample:
+            if self._logic_match(ast, self._current_sample["target_ast"]):
+                reward += _W_MATCH
+                info["exact_match"] = True
+            else:
+                info["exact_match"] = False
+
+        return ConstraintObservation(
+            prompt=self._current_sample["prompt"],
+            done=True,
+            reward=round(reward, 4),
+            info=info,
+        )
+
+    @property
+    def state(self):
+        return self._state
+
+    # ------------------------------------------------------------------
+    # Validation helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _logic_match(ast: Dict[str, Any], target: Dict[str, Any]) -> bool:
+        """
+        Compare two ASTs on every logically meaningful field, ignoring "name".
+
+        Fields compared:
+          • type     – hard / soft
+          • forall   – same variable declarations (order-independent)
+          • where    – optional guard expression (string equality)
+          • assert   – constraint body  } exactly one
+          • minimize – objective body   }
+
+        "name" is intentionally excluded — it is a free-form user-chosen
+        snake_case identifier that has no effect on the constraint's semantics.
+        """
+        _LOGIC_KEYS = {"type", "forall", "where", "assert", "minimize"}
+
+        # Collect only logic keys present in either dict
+        all_keys = (set(ast.keys()) | set(target.keys())) & _LOGIC_KEYS
+
+        for key in all_keys:
+            a_val = ast.get(key)
+            t_val = target.get(key)
+
+            if key == "forall":
+                # Order of variable declarations doesn't matter;
+                # compare as a frozenset of (var, domain) pairs.
+                try:
+                    a_set = frozenset(
+                        (d["var"], d["domain"]) for d in (a_val or [])
+                    )
+                    t_set = frozenset(
+                        (d["var"], d["domain"]) for d in (t_val or [])
+                    )
+                    if a_set != t_set:
+                        return False
+                except (TypeError, KeyError):
+                    return False
+            else:
+                if a_val != t_val:
+                    return False
+
+        return True
+
+    def _validate_structure(self, ast: Dict[str, Any]) -> bool:
+        """Return True if AST follows the expected schema."""
+
+        # 1. Top-level type field must be exactly "hard" or "soft"
+        if ast.get("type") not in {"hard", "soft"}:
+            return False
+
+        # 2. Must have forall
+        if "forall" not in ast:
+            return False
+
+        if not isinstance(ast["forall"], list) or len(ast["forall"]) == 0:
+            return False
+
+        # 3. Build variable scope from forall declarations
+        scope: Dict[str, str] = {}
+        for var_decl in ast["forall"]:
+            var    = var_decl.get("var")
+            domain = var_decl.get("domain")
+
+            if not var or not domain:
+                return False
+
+            if domain not in VALID_DOMAINS:
+                return False
+
+            scope[var] = domain
+
+        # 4. Validate optional WHERE clause
+        if "where" in ast:
+            if not self._validate_expression(ast["where"], scope):
+                return False
+
+        # 5. Validate payload: assert OR minimize (one required)
+        if "assert" in ast:
+            return self._validate_expression(ast["assert"], scope)
+        elif "minimize" in ast:
+            return self._validate_expression(ast["minimize"], scope)
+        else:
+            return False
+
+    def _validate_expression(self, expr: str, scope: Dict[str, str]) -> bool:
+        """
+        Validate that all identifiers in an expression are in scope or known.
+
+        Follows the grammar:
+          boolean_expr    ::= … AND | OR | NOT … | comparison | predicate | "(" … ")"
+          comparison      ::= arithmetic_expr comp_op arithmetic_expr
+          arithmetic_expr ::= … + | - | * … | function_call | number | identifier
+          number          ::= digit { digit }   (multi-digit allowed)
+
+        Extensions beyond the BNF (accepted but not spec'd):
+          • String literals  `'online'`, `'practical'` – stripped before tokenising
+          • IN keyword       – used in Python-style membership tests
+        """
+        # Strip quoted string literals (grammar extension – not in BNF)
+        expr_stripped = re.sub(r"'[^']*'", "", expr)
+        expr_stripped = re.sub(r'"[^"]*"', "", expr_stripped)
+
+        # Strip all numbers (grammar: number ::= digit { digit })
+        expr_stripped = re.sub(r"\b\d+\b", "", expr_stripped)
+
+        tokens = self._extract_identifiers(expr_stripped)
+
+        # Keywords defined in the grammar + accepted extensions
+        GRAMMAR_KEYWORDS = {"AND", "OR", "NOT"}          # boolean_expr operators
+        EXTENSIONS       = {"IN", "true", "false", "null"}  # beyond BNF
+
+        for token in tokens:
+            if token in scope:
+                continue
+            if token in VALID_FUNCTIONS:
+                continue
+            if token in GRAMMAR_KEYWORDS or token in EXTENSIONS:
+                continue
+            # Unknown identifier
+            return False
+
+        return self._validate_function_calls(expr)
+
+
+    @staticmethod
+    def _validate_function_calls(expr: str) -> bool:
+        """Validate that all function calls use known functions with correct arity.
+
+        Handles nested calls like SUM(occupies(b, sub, d, s)) by counting only
+        top-level commas (those not inside inner parentheses) to determine arity.
+        """
+        # Find every function call by name; walk the string to pair parens properly
+        func_pattern = re.compile(r"([a-zA-Z_][a-zA-Z0-9_]*)\(")
+
+        i = 0
+        while i < len(expr):
+            m = func_pattern.search(expr, i)
+            if not m:
+                break
+
+            func_name = m.group(1)
+            # Position after the opening '('
+            start = m.end()
+
+            # Walk to find the matching closing ')'
+            depth = 1
+            j = start
+            while j < len(expr) and depth > 0:
+                if expr[j] == "(":
+                    depth += 1
+                elif expr[j] == ")":
+                    depth -= 1
+                j += 1
+
+            # args_str is everything between the outer parens
+            args_str = expr[start : j - 1]
+
+            if func_name in VALID_FUNCTIONS:
+                # Count top-level commas (depth-0 within args_str)
+                if args_str.strip() == "":
+                    top_level_args = 0
+                else:
+                    top_level_args = 1
+                    inner_depth = 0
+                    for ch in args_str:
+                        if ch == "(":
+                            inner_depth += 1
+                        elif ch == ")":
+                            inner_depth -= 1
+                        elif ch == "," and inner_depth == 0:
+                            top_level_args += 1
+
+                expected = VALID_FUNCTIONS[func_name]
+                if top_level_args != expected:
+                    return False
+            else:
+                # Not a DSL function — unknown call
+                return False
+
+            i = j  # advance past this call
+
+        return True
+
+
+    @staticmethod
+    def _extract_identifiers(expr: str):
+        return set(re.findall(r"[a-zA-Z_][a-zA-Z0-9_]*", expr))
+
+
+# ---------------------------------------------------------------------------
+# Quick smoke-test
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import json as _json
+
+    try:
+        from ..dataset_example import dataset as _ds
+    except ImportError:
+        from constraint_env.dataset_example import dataset as _ds  # type: ignore
+
+    env = ConstraintEnvironment(_ds)
+
+    for difficulty in ("easy", "medium", "hard"):
+        obs = env.reset(task_id=difficulty)
+        print(f"\n[{difficulty.upper()}] prompt: {obs.prompt}")
+
+        # send perfect answer
+        target = env._current_sample["target_ast"]
+        action = ConstraintAction(ast_output=_json.dumps(target))
+        result = env.step(action)
+        print(f"  reward={result.reward}  done={result.done}  info={result.info}")
+
+        # send bad JSON
+        obs2  = env.reset(task_id=difficulty)
+        bad   = ConstraintAction(ast_output="this is not json")
+        res2  = env.step(bad)
+        print(f"  [bad JSON] reward={res2.reward}  info={res2.info}")

server/requirements.txt

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