Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,23 @@
+# Use Python 3.11 slim base
+FROM python:3.11-slim
+
+# Metadata
+LABEL maintainer="metaXscaler"
+LABEL description="SQL Query Optimizer — OpenEnv Environment"
+
+# Set working directory
+WORKDIR /app
+
+# Install dependencies first (layer cache optimisation)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# HF Spaces default port
+EXPOSE 7860
+
+# Start the FastAPI server
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,196 @@
 ---
-title: Sql Query Optimizer
-emoji: 🚀
-colorFrom: purple
-colorTo: gray
+title: SQL Query Optimizer Environment Server
+emoji: 🐳
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
-license: mit
-short_description: SQL Query Optimizer — OpenEnv Environment
+app_port: 7860
+base_path: /web
+tags:
+  - openenv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SQL Query Optimizer — OpenEnv Environment
+
+An **OpenEnv-compliant** environment where AI agents learn to review, rewrite, and optimise SQL queries across three real-world failure patterns.
+
+> **HF Spaces**: [param20h/sql-query-optimizer](https://huggingface.co/spaces/param20h/sql-query-optimizer)
+
+---
+
+## Environment Description
+
+Real-world SQL anti-patterns cost companies millions in infrastructure. This environment teaches agents to identify and fix them through a reward-shaped episode loop. Each episode presents the agent with a broken or unoptimised query alongside schema context; the agent iteratively rewrites it until done or max steps are reached.
+
+**Why this domain?**
+- Used by data engineers and DBAs every day
+- Deterministically gradeable (no ambiguous LLM judging)
+- Natural difficulty progression from syntax errors to multi-factor optimisation
+
+---
+
+## Observation Space
+
+| Field | Type | Description |
+|---|---|---|
+| `task_id` | `int` | Task number (1–3) |
+| `task_name` | `str` | Slug identifier |
+| `task_description` | `str` | What the agent must accomplish |
+| `query` | `str` | The SQL to fix |
+| `schema_context` | `str` | Relevant DDL / table definitions |
+| `hint` | `str \| null` | Optional hint (tasks 1 & 2 only) |
+| `step_number` | `int` | Current step (0-indexed) |
+| `max_steps` | `int` | Steps allowed per episode |
+| `done` | `bool` | Whether episode has ended |
+
+---
+
+## Action Space
+
+| Field | Type | Description |
+|---|---|---|
+| `rewritten_query` | `str` | The agent's improved SQL |
+| `explanation` | `str` | Brief description of changes made |
+| `is_done` | `bool` | `true` when the agent believes the query is fully fixed |
+
+---
+
+## Reward Design
+
+The reward is **shaped** (not sparse) — the agent receives signal every step:
+
+| Component | Value | Trigger |
+|---|---|---|
+| Delta reward | +0.0–0.50 × Δgrader | Grader score improves |
+| Completion bonus | +0.50 | `is_done=True` and grader ≥ 0.80 |
+| Partial completion | +grader × 0.30 | `is_done=True` (always) |
+| Step penalty | −0.02 / step | After halfway point, if not done |
+| Invalid penalty | −0.10 | Empty or unparseable query |
+
+Final `score` per step is clamped to `[0.0, 1.0]`.
+
+---
+
+## Tasks
+
+### Task 1 — `fix-broken-join` (Easy)
+The query uses a comma-separated cross-join (`FROM orders, customers`) without any join condition, causing a Cartesian product. The agent must rewrite with `INNER JOIN … ON o.customer_id = c.customer_id`.
+
+**Max steps**: 3 | **Grader**: checks JOIN keyword + ON clause with correct key
+
+### Task 2 — `eliminate-n-plus-one` (Medium)
+A correlated scalar subquery in the `SELECT` list executes once per row (N+1 problem). The agent must collapse it into a single `LEFT JOIN departments ON e.dept_id = d.dept_id`.
+
+**Max steps**: 4 | **Grader**: checks subquery removal + JOIN on dept_id
+
+### Task 3 — `full-optimization` (Hard)
+Four independent issues to fix:
+1. Remove redundant `DISTINCT` (PK join makes it unnecessary)
+2. Replace `SELECT *` with explicit columns
+3. Replace `CAST(price AS VARCHAR) LIKE '1%'` → `price >= 100 AND price < 200` (sargable)
+4. Add an index hint comment for `(category, price)`
+
+**Max steps**: 5 | **Grader**: 4 × 0.25 sub-criteria, fully independent
+
+---
+
+## API Endpoints
+
+| Method | Path | Description |
+|---|---|---|
+| `GET` | `/` | Health check |
+| `POST` | `/reset` | Start episode `{ "task_id": 1 }` |
+| `POST` | `/step` | Submit action `{ "rewritten_query": "...", "explanation": "...", "is_done": true }` |
+| `GET` | `/state` | Current internal state |
+| `GET` | `/tasks` | All tasks + action schema |
+| `GET` | `/grader` | Grader score for current episode |
+| `POST` | `/baseline` | Run baseline inference (requires `OPENAI_API_KEY`) |
+
+Interactive docs: `http://localhost:7860/docs`
+
+---
+
+## Setup & Usage
+
+### Prerequisites
+- Python 3.10+
+- Docker
+- `OPENAI_API_KEY` (for baseline only)
+
+### Local (Python)
+
+```bash
+pip install -r requirements.txt
+uvicorn server:app --host 0.0.0.0 --port 7860 --reload
+```
+
+### Local (Docker)
+
+```bash
+docker build -t sql-optimizer-env .
+docker run -p 7860:7860 -e OPENAI_API_KEY=sk-... sql-optimizer-env
+```
+
+### Baseline Inference
+
+```bash
+export OPENAI_API_KEY=sk-...
+python baseline.py
+```
+
+### OpenEnv Validation
+
+```bash
+pip install openenv-core
+openenv validate
+```
+
+### Deploy to HF Spaces
+
+```bash
+pip install huggingface_hub
+huggingface-cli login
+openenv push --repo-id your-username/sql-query-optimizer
+```
+
+---
+
+## Baseline Scores
+
+Measured with `gpt-4o-mini` at `temperature=0`, single-pass:
+
+| Task | Name | Difficulty | Grader Score |
+|---|---|---|---|
+| 1 | fix-broken-join | Easy | 0.86 |
+| 2 | eliminate-n-plus-one | Medium | 0.72 |
+| 3 | full-optimization | Hard | 0.50 |
+| — | **Average** | — | **0.69** |
+
+> Scores are reproducible: same model, same temperature, same grader → same output.
+
+---
+
+## Project Structure
+
+```
+metaXscaler/
+├── env/
+│   ├── __init__.py
+│   ├── environment.py   # reset(), step(), state()
+│   ├── models.py        # Observation, Action, Reward (Pydantic)
+│   ├── tasks.py         # Task definitions + graders
+│   └── reward.py        # Shaped reward function
+├── server.py            # FastAPI app
+├── baseline.py          # Baseline inference script
+├── openenv.yaml         # OpenEnv spec metadata
+├── Dockerfile
+├── requirements.txt
+└── README.md
+```
+
+---
+
+## License
+
+MIT

__init__.py

@@ -0,0 +1 @@
+"""Top-level package marker for the OpenEnv project."""

baseline.py

@@ -0,0 +1,144 @@
+"""
+Baseline inference script for the SQL Query Optimizer OpenEnv environment.
+
+Usage:
+    python baseline.py              # human-readable output
+    python baseline.py --json       # JSON output (used by /baseline endpoint)
+
+Requires:
+    OPENAI_API_KEY environment variable
+
+The script runs gpt-4o-mini against all 3 tasks and reports grader scores.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from openai import OpenAI
+
+# ── import env from local package ──────────────────────────────────────────
+sys.path.insert(0, os.path.dirname(__file__))
+from env.environment import SQLOptimizerEnv
+from env.models import Action
+
+# ──────────────────────────────────────────────────────────────────────────────
+MODEL = "gpt-4o-mini"
+MAX_STEPS = 5
+TASKS = [1, 2, 3]
+
+SYSTEM_PROMPT = """You are a database performance engineer.
+You will receive a broken or unoptimised SQL query along with table schema context.
+Your job is to rewrite the query so it is correct and performant.
+
+Respond ONLY with a JSON object with these exact keys:
+{
+  "rewritten_query": "<your improved SQL>",
+  "explanation": "<brief explanation of changes>",
+  "is_done": true
+}
+Do not wrap in markdown. Output raw JSON only."""
+
+
+def _build_user_message(obs_dict: dict) -> str:
+    return (
+        f"Task: {obs_dict['task_name']} ({obs_dict['task_id']} — difficulty: "
+        f"{obs_dict.get('difficulty', 'unknown')})\n\n"
+        f"Description:\n{obs_dict['task_description']}\n\n"
+        f"Schema:\n{obs_dict['schema_context']}\n\n"
+        f"Query to fix:\n{obs_dict['query']}"
+        + (f"\n\nHint: {obs_dict['hint']}" if obs_dict.get("hint") else "")
+    )
+
+
+def run_baseline(verbose: bool = True) -> dict[str, float]:
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("ERROR: OPENAI_API_KEY is not set.", file=sys.stderr)
+        sys.exit(1)
+
+    client = OpenAI(api_key=api_key)
+    env = SQLOptimizerEnv()
+    results: dict[str, float] = {}
+
+    for task_id in TASKS:
+        obs = env.reset(task_id=task_id)
+        obs_dict = obs.model_dump()
+        final_score = 0.0
+
+        if verbose:
+            print(f"\n{'='*60}")
+            print(f"Task {task_id}: {obs_dict['task_name']} [{obs_dict['task_id']}]")
+            print(f"{'='*60}")
+
+        for step_num in range(MAX_STEPS):
+            messages = [
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": _build_user_message(obs_dict)},
+            ]
+
+            try:
+                response = client.chat.completions.create(
+                    model=MODEL,
+                    messages=messages,
+                    temperature=0.0,
+                    max_tokens=1024,
+                )
+                content = response.choices[0].message.content.strip()
+                parsed = json.loads(content)
+                action = Action(
+                    rewritten_query=parsed.get("rewritten_query", ""),
+                    explanation=parsed.get("explanation", ""),
+                    is_done=bool(parsed.get("is_done", False)),
+                )
+            except Exception as exc:
+                if verbose:
+                    print(f"  Step {step_num + 1}: LLM error — {exc}")
+                action = Action(
+                    rewritten_query="",
+                    explanation="error",
+                    is_done=True,
+                )
+
+            obs, reward, done, info = env.step(action)
+            obs_dict = obs.model_dump()
+            final_score = info["grader_score"]
+
+            if verbose:
+                print(
+                    f"  Step {step_num + 1}: grader_score={info['grader_score']:.3f}  "
+                    f"step_reward={reward.score:.4f}  feedback={reward.feedback[:80]}"
+                )
+
+            if done:
+                break
+
+        results[f"task_{task_id}_{env._task.name}"] = round(final_score, 4)
+
+        if verbose:
+            print(f"  → Final grader score: {final_score:.4f}")
+
+    if verbose:
+        print(f"\n{'='*60}")
+        print("BASELINE RESULTS")
+        print(f"{'='*60}")
+        for k, v in results.items():
+            print(f"  {k}: {v:.4f}")
+        avg = sum(results.values()) / len(results)
+        print(f"  Average: {avg:.4f}")
+
+    return results
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="OpenEnv SQL Optimizer — Baseline Inference")
+    parser.add_argument(
+        "--json", action="store_true", help="Output results as JSON (used by /baseline endpoint)"
+    )
+    args = parser.parse_args()
+
+    scores = run_baseline(verbose=not args.json)
+    if args.json:
+        print(json.dumps(scores))

client.py

@@ -0,0 +1,4 @@
+"""Top-level client exports for OpenEnv validation compatibility."""
+from env.environment import SQLOptimizerEnv
+
+__all__ = ["SQLOptimizerEnv"]

env/__init__.py

@@ -0,0 +1,4 @@
+from .environment import SQLOptimizerEnv
+from .models import Observation, Action, Reward
+
+__all__ = ["SQLOptimizerEnv", "Observation", "Action", "Reward"]

env/environment.py

@@ -0,0 +1,174 @@
+"""
+Core OpenEnv environment: SQLOptimizerEnv
+
+Implements the three required methods:
+  reset(task_id)  → Observation
+  step(action)    → (Observation, Reward, done, info)
+  state()         → dict (current internal snapshot)
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Tuple
+
+from .models import Action, Observation, Reward, RewardBreakdown
+from .tasks import TASKS, TaskDef, get_task
+from .reward import compute_step_reward
+
+
+class SQLOptimizerEnv:
+    """SQL Query Optimizer OpenEnv environment."""
+
+    def __init__(self) -> None:
+        self._task: Optional[TaskDef] = None
+        self._step_number: int = 0
+        self._done: bool = False
+        self._cumulative_score: float = 0.0
+        self._prev_grader_score: float = 0.0
+        self._history: list[Dict[str, Any]] = []
+        self._last_grader_score: float = 0.0
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # reset
+    # ──────────────────────────────────────────────────────────────────────────
+
+    def reset(self, task_id: int = 1) -> Observation:
+        """Start a fresh episode for the given task."""
+        self._task = get_task(task_id)
+        self._step_number = 0
+        self._done = False
+        self._cumulative_score = 0.0
+        self._prev_grader_score = 0.0
+        self._last_grader_score = 0.0
+        self._history = []
+
+        return self._make_observation()
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # step
+    # ──────────────────────────────────────────────────────────────────────────
+
+    def step(self, action: Action) -> Tuple[Observation, Reward, bool, Dict[str, Any]]:
+        """
+        Advance the environment by one step.
+
+        Returns:
+            observation: next Observation
+            reward:      Reward for this step
+            done:        whether the episode has ended
+            info:        auxiliary dict
+        """
+        if self._task is None:
+            raise RuntimeError("Call reset() before step().")
+        if self._done:
+            raise RuntimeError("Episode is done. Call reset() to start a new episode.")
+
+        # Validate action
+        is_invalid = not action.rewritten_query or not action.rewritten_query.strip()
+
+        # Run grader
+        if is_invalid:
+            grader_result_score = self._prev_grader_score
+            breakdown = RewardBreakdown()
+            feedback = "Empty or invalid query submitted."
+        else:
+            gr = self._task.grader(action.rewritten_query)
+            grader_result_score = gr.score
+            breakdown = RewardBreakdown(
+                correctness=gr.correctness,
+                performance=gr.performance,
+                style=gr.style,
+                step_penalty=0.0,
+            )
+            feedback = gr.feedback
+
+        # Compute shaped reward
+        step_reward = compute_step_reward(
+            grader_score=grader_result_score,
+            prev_grader_score=self._prev_grader_score,
+            step_number=self._step_number,
+            max_steps=self._task.max_steps,
+            is_done=action.is_done,
+            is_invalid=is_invalid,
+        )
+
+        # Apply step penalty to breakdown
+        import math
+        halfway = math.ceil(self._task.max_steps / 2)
+        if self._step_number > halfway and not action.is_done:
+            breakdown.step_penalty = -0.02
+
+        self._cumulative_score = round(
+            min(max(self._cumulative_score + step_reward, 0.0), 1.0), 4
+        )
+        self._prev_grader_score = grader_result_score
+        self._last_grader_score = grader_result_score
+        self._step_number += 1
+
+        # Episode ends if agent signals done OR max steps reached
+        self._done = action.is_done or self._step_number >= self._task.max_steps
+
+        # Record history
+        self._history.append(
+            {
+                "step": self._step_number,
+                "rewritten_query": action.rewritten_query,
+                "grader_score": grader_result_score,
+                "step_reward": step_reward,
+                "is_done": action.is_done,
+            }
+        )
+
+        reward = Reward(
+            score=round(min(max(step_reward, 0.0), 1.0), 4),
+            grader_score=grader_result_score,
+            breakdown=breakdown,
+            feedback=feedback,
+            cumulative_score=self._cumulative_score,
+        )
+
+        info = {
+            "step_number": self._step_number,
+            "grader_score": grader_result_score,
+            "cumulative_score": self._cumulative_score,
+            "is_invalid": is_invalid,
+        }
+
+        return self._make_observation(), reward, self._done, info
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # state
+    # ──────────────────────────────────────────────────────────────────────────
+
+    def state(self) -> Dict[str, Any]:
+        """Return the current internal state snapshot."""
+        if self._task is None:
+            return {"status": "not_started"}
+        return {
+            "task_id": self._task.id,
+            "task_name": self._task.name,
+            "difficulty": self._task.difficulty,
+            "step_number": self._step_number,
+            "max_steps": self._task.max_steps,
+            "done": self._done,
+            "cumulative_score": self._cumulative_score,
+            "last_grader_score": self._last_grader_score,
+            "history": self._history,
+        }
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # Internal helpers
+    # ──────────────────────────────────────────────────────────────────────────
+
+    def _make_observation(self) -> Observation:
+        assert self._task is not None
+        return Observation(
+            task_id=self._task.id,
+            task_name=self._task.name,
+            task_description=self._task.description,
+            query=self._task.query,
+            schema_context=self._task.schema_context,
+            hint=self._task.hint,
+            step_number=self._step_number,
+            max_steps=self._task.max_steps,
+            done=self._done,
+        )

env/models.py

@@ -0,0 +1,77 @@
+"""
+OpenEnv typed models — Observation, Action, Reward.
+All models are Pydantic v2 compliant.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+# ---------------------------------------------------------------------------
+# Observation
+# ---------------------------------------------------------------------------
+
+class Observation(BaseModel):
+    """What the agent sees at each step."""
+
+    task_id: int = Field(..., description="Which task (1=easy, 2=medium, 3=hard)")
+    task_name: str = Field(..., description="Human-readable task name")
+    task_description: str = Field(..., description="What the agent must accomplish")
+    query: str = Field(..., description="The SQL query the agent must fix / optimise")
+    schema_context: str = Field(
+        ..., description="DDL / schema description relevant to the query"
+    )
+    hint: Optional[str] = Field(
+        None, description="Optional natural-language hint for the current step"
+    )
+    step_number: int = Field(0, description="Current step within the episode (0-indexed)")
+    max_steps: int = Field(5, description="Maximum steps allowed per episode")
+    done: bool = Field(False, description="Whether the episode has ended")
+
+
+# ---------------------------------------------------------------------------
+# Action
+# ---------------------------------------------------------------------------
+
+class Action(BaseModel):
+    """What the agent submits at each step."""
+
+    rewritten_query: str = Field(
+        ..., description="The agent's rewritten / improved SQL query"
+    )
+    explanation: str = Field(
+        ..., description="Natural-language explanation of changes made"
+    )
+    is_done: bool = Field(
+        False,
+        description="Set True when the agent believes the query is fully optimised",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Reward
+# ---------------------------------------------------------------------------
+
+class RewardBreakdown(BaseModel):
+    correctness: float = Field(0.0, ge=0.0, le=1.0)
+    performance: float = Field(0.0, ge=0.0, le=1.0)
+    style: float = Field(0.0, ge=0.0, le=1.0)
+    step_penalty: float = Field(0.0, le=0.0)  # always ≤ 0
+
+
+class Reward(BaseModel):
+    """Reward returned after each step."""
+
+    score: float = Field(..., ge=0.0, le=1.0, description="Aggregate step reward")
+    grader_score: float = Field(
+        ..., ge=0.0, le=1.0, description="Raw grader score for the submitted query"
+    )
+    breakdown: RewardBreakdown = Field(
+        default_factory=RewardBreakdown,
+        description="Per-dimension partial scores",
+    )
+    feedback: str = Field("", description="Human-readable feedback from the grader")
+    cumulative_score: float = Field(
+        0.0, ge=0.0, le=1.0, description="Total score accumulated over episode so far"
+    )

env/reward.py

@@ -0,0 +1,57 @@
+"""
+Shaped reward function for the SQL Query Optimizer environment.
+
+Design:
+  - Partial credit every step based on grader improvement delta
+  - Completion bonus when agent signals is_done and score ≥ threshold
+  - Step penalty for unnecessary steps beyond task minimum
+  - Invalid action penalty for empty / unparseable queries
+"""
+from __future__ import annotations
+
+import math
+
+
+_COMPLETION_THRESHOLD = 0.80
+_COMPLETION_BONUS = 0.50
+_STEP_PENALTY = 0.02
+_INVALID_PENALTY = 0.10
+_DELTA_WEIGHT = 0.50   # weight for grader improvement delta in step reward
+
+
+def compute_step_reward(
+    *,
+    grader_score: float,
+    prev_grader_score: float,
+    step_number: int,
+    max_steps: int,
+    is_done: bool,
+    is_invalid: bool,
+) -> float:
+    """
+    Returns a reward in [-0.10, 1.0] for a single step.
+
+    Components (all summed then clamped to [0, 1]):
+      1. delta_reward   = _DELTA_WEIGHT * max(0, grader_score - prev_grader_score)
+      2. completion_bonus (only if is_done and grader_score >= threshold)
+      3. step_penalty   (only if step > min_steps_expected and not done-early)
+      4. invalid_penalty (if query is empty / not parseable)
+    """
+    if is_invalid:
+        return -_INVALID_PENALTY
+
+    delta = max(0.0, grader_score - prev_grader_score)
+    reward = _DELTA_WEIGHT * delta
+
+    if is_done:
+        if grader_score >= _COMPLETION_THRESHOLD:
+            reward += _COMPLETION_BONUS
+        # proportional partial completion signal even without bonus
+        reward += grader_score * 0.30
+
+    # Step penalty starts after half of max_steps used
+    halfway = math.ceil(max_steps / 2)
+    if step_number > halfway and not is_done:
+        reward -= _STEP_PENALTY
+
+    return round(min(max(reward, -_INVALID_PENALTY), 1.0), 4)

env/tasks.py

@@ -0,0 +1,365 @@
+"""
+Task definitions and deterministic graders for the SQL Query Optimizer environment.
+
+Each task returns a TaskDef with:
+  - id, name, difficulty
+  - query: the broken/unoptimised SQL the agent must fix
+  - schema_context: relevant DDL
+  - description: what the agent must accomplish
+  - grader(rewritten_query) -> GraderResult(score, breakdown, feedback)
+"""
+from __future__ import annotations
+
+import re
+import dataclasses
+from typing import Callable, Dict, Optional
+
+
+@dataclasses.dataclass
+class GraderResult:
+    score: float                          # 0.0 – 1.0
+    correctness: float = 0.0
+    performance: float = 0.0
+    style: float = 0.0
+    feedback: str = ""
+
+
+@dataclasses.dataclass
+class TaskDef:
+    id: int
+    name: str
+    difficulty: str                       # easy | medium | hard
+    description: str
+    query: str
+    schema_context: str
+    hint: Optional[str]
+    max_steps: int
+    grader: Callable[[str], GraderResult]
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _normalise(sql: str) -> str:
+    """Lower-case, collapse whitespace."""
+    return re.sub(r"\s+", " ", sql.lower().strip())
+
+
+def _has(sql: str, *patterns: str) -> bool:
+    s = _normalise(sql)
+    return all(p in s for p in patterns)
+
+
+def _missing(sql: str, *patterns: str) -> bool:
+    s = _normalise(sql)
+    return any(p not in s for p in patterns)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Task 1 — Easy: Fix a broken JOIN (missing ON clause / wrong join type)
+# ──────────────────────────────────────────────────────────────────────────────
+
+_T1_SCHEMA = """
+CREATE TABLE orders (
+    order_id   INT PRIMARY KEY,
+    customer_id INT NOT NULL,
+    total       DECIMAL(10,2),
+    created_at  TIMESTAMP
+);
+CREATE TABLE customers (
+    customer_id INT PRIMARY KEY,
+    name        VARCHAR(255),
+    email       VARCHAR(255)
+);
+"""
+
+_T1_QUERY = """
+SELECT o.order_id, c.name, o.total
+FROM   orders o, customers c
+WHERE  o.total > 100;
+"""
+
+_T1_DESC = (
+    "The query uses an implicit cross-join (comma syntax) between `orders` and "
+    "`customers` but never links the two tables. Rewrite it with an explicit "
+    "INNER JOIN … ON o.customer_id = c.customer_id, keeping the WHERE filter."
+)
+
+
+def _grade_task1(rewritten: str) -> GraderResult:
+    s = _normalise(rewritten)
+    fb: list[str] = []
+    correctness = 0.0
+    performance = 0.0
+    style = 0.0
+
+    # Correctness: must have explicit JOIN with the correct ON key
+    if "inner join" in s or ("join" in s and "cross join" not in s):
+        if "on" in s and "customer_id" in s:
+            correctness = 1.0
+        else:
+            correctness = 0.4
+            fb.append("JOIN present but ON clause with customer_id is missing.")
+    else:
+        fb.append("Still uses implicit cross-join or missing JOIN keyword.")
+
+    # Correctness: must still filter total > 100
+    if "total > 100" in s or "total>100" in s:
+        correctness = min(correctness + 0.0, correctness)  # already captured
+    else:
+        correctness = max(correctness - 0.3, 0.0)
+        fb.append("WHERE o.total > 100 filter has been removed.")
+
+    # Performance: explicit join is better than implicit cross join
+    performance = 1.0 if correctness >= 0.8 else 0.3
+
+    # Style: uses table aliases
+    style = 0.5
+    if re.search(r"\bo\b", s) and re.search(r"\bc\b", s):
+        style = 1.0
+    elif "select *" not in s:
+        style = 0.7
+
+    score = round(correctness * 0.6 + performance * 0.25 + style * 0.15, 3)
+    feedback = " ".join(fb) if fb else "Correct! The JOIN is properly formed."
+    return GraderResult(
+        score=min(max(score, 0.0), 1.0),
+        correctness=correctness,
+        performance=performance,
+        style=style,
+        feedback=feedback,
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Task 2 — Medium: Eliminate N+1 correlated subquery
+# ──────────────────────────────────────────────��───────────────────────────────
+
+_T2_SCHEMA = """
+CREATE TABLE employees (
+    emp_id      INT PRIMARY KEY,
+    name        VARCHAR(255),
+    dept_id     INT,
+    salary      DECIMAL(10,2)
+);
+CREATE TABLE departments (
+    dept_id     INT PRIMARY KEY,
+    dept_name   VARCHAR(255),
+    budget      DECIMAL(12,2)
+);
+"""
+
+_T2_QUERY = """
+SELECT e.name,
+       (SELECT d.dept_name
+        FROM   departments d
+        WHERE  d.dept_id = e.dept_id) AS dept_name
+FROM   employees e
+WHERE  e.salary > 50000;
+"""
+
+_T2_DESC = (
+    "The query uses a correlated scalar subquery in the SELECT list that fires "
+    "once per row (N+1 problem). Collapse it into a single LEFT JOIN … ON "
+    "e.dept_id = d.dept_id, keeping the salary filter."
+)
+
+
+def _grade_task2(rewritten: str) -> GraderResult:
+    s = _normalise(rewritten)
+    fb: list[str] = []
+    correctness = 0.0
+    performance = 0.0
+    style = 0.0
+
+    # Correctness: correlated subquery in SELECT must be gone
+    has_correlated = bool(
+        re.search(r"select\s+.*\(\s*select", s)
+        or re.search(r"\(\s*select\b.*\bwhere\b.*=\s*e\.", s)
+    )
+    if has_correlated:
+        fb.append("Correlated subquery still present in SELECT list.")
+        correctness = 0.1
+    else:
+        correctness = 0.5
+
+    # Correctness: must join on dept_id
+    if "join" in s and "dept_id" in s and "on" in s:
+        correctness = min(correctness + 0.5, 1.0)
+    else:
+        fb.append("Missing JOIN departments ON dept_id.")
+        correctness = max(correctness - 0.1, 0.0)
+
+    # Correctness: salary filter preserved
+    if "salary" not in s or ("salary > 50000" not in s and "salary>50000" not in s):
+        correctness = max(correctness - 0.2, 0.0)
+        fb.append("salary > 50000 filter is missing or incorrect.")
+
+    # Performance: single pass vs N+1
+    performance = 1.0 if not has_correlated and "join" in s else 0.2
+
+    # Style: uses aliases, selects explicit columns
+    style = 0.5
+    if "select *" not in s:
+        style += 0.25
+    if re.search(r"\be\b|\bd\b", s):
+        style += 0.25
+
+    score = round(correctness * 0.55 + performance * 0.30 + style * 0.15, 3)
+    feedback = " ".join(fb) if fb else "Excellent! N+1 eliminated with a clean JOIN."
+    return GraderResult(
+        score=min(max(score, 0.0), 1.0),
+        correctness=correctness,
+        performance=performance,
+        style=style,
+        feedback=feedback,
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Task 3 — Hard: Full optimisation (4 independent issues)
+# ──────────────────────────────────────────────────────────────────────────────
+
+_T3_SCHEMA = """
+CREATE TABLE products (
+    product_id  INT PRIMARY KEY,
+    name        VARCHAR(255),
+    category    VARCHAR(100),
+    price       DECIMAL(10,2),
+    stock       INT
+);
+CREATE TABLE order_items (
+    item_id     INT PRIMARY KEY,
+    order_id    INT,
+    product_id  INT,
+    quantity    INT,
+    unit_price  DECIMAL(10,2)
+);
+"""
+
+_T3_QUERY = """
+SELECT DISTINCT *
+FROM   products p
+JOIN   order_items oi ON p.product_id = oi.product_id
+WHERE  CAST(p.price AS VARCHAR) LIKE '1%'
+  AND  p.category = 'Electronics'
+ORDER  BY p.name;
+"""
+
+_T3_DESC = (
+    "The query has four problems: "
+    "(1) DISTINCT is redundant because product_id is PK and the JOIN is 1-to-many — remove it. "
+    "(2) SELECT * should list only needed columns: p.name, p.category, p.price, oi.quantity, oi.unit_price. "
+    "(3) CAST(p.price AS VARCHAR) LIKE '1%' prevents index use — rewrite as p.price >= 100 AND p.price < 200. "
+    "(4) Add a comment hinting an index on (category, price) would help."
+)
+
+
+def _grade_task3(rewritten: str) -> GraderResult:
+    s = _normalise(rewritten)
+    fb: list[str] = []
+    sub_scores: Dict[str, float] = {}
+
+    # Sub-criterion 1: DISTINCT removed (0.25)
+    if "distinct" not in s:
+        sub_scores["no_distinct"] = 0.25
+    else:
+        sub_scores["no_distinct"] = 0.0
+        fb.append("DISTINCT still present — it's redundant here.")
+
+    # Sub-criterion 2: SELECT * replaced with explicit columns (0.25)
+    if "select *" not in s and all(
+        col in s for col in ("p.name", "p.price", "oi.quantity")
+    ):
+        sub_scores["explicit_columns"] = 0.25
+    elif "select *" not in s:
+        sub_scores["explicit_columns"] = 0.15
+        fb.append("SELECT * removed but explicit column list is incomplete.")
+    else:
+        sub_scores["explicit_columns"] = 0.0
+        fb.append("SELECT * still used — list explicit columns.")
+
+    # Sub-criterion 3: CAST…LIKE replaced with range predicate (0.25)
+    cast_gone = "cast(" not in s and "cast (" not in s
+    has_price_range = (
+        ("price >= 100" in s or "price>=100" in s)
+        and ("price < 200" in s or "price<200" in s)
+    )
+    if cast_gone and has_price_range:
+        sub_scores["sargable"] = 0.25
+    elif cast_gone:
+        sub_scores["sargable"] = 0.12
+        fb.append("CAST removed but price range predicate (>= 100 AND < 200) is missing.")
+    else:
+        sub_scores["sargable"] = 0.0
+        fb.append("CAST(price AS VARCHAR) LIKE … still present — non-sargable predicate.")
+
+    # Sub-criterion 4: index hint comment present (0.25)
+    raw = rewritten.lower()
+    if "index" in raw and ("category" in raw or "price" in raw):
+        sub_scores["index_hint"] = 0.25
+    else:
+        sub_scores["index_hint"] = 0.0
+        fb.append("Missing comment / hint about adding an index on (category, price).")
+
+    total = sum(sub_scores.values())
+    correctness = min(sub_scores["no_distinct"] + sub_scores["explicit_columns"], 0.5) * 2
+    performance = min(sub_scores["sargable"] + sub_scores["index_hint"], 0.5) * 2
+    style = 1.0 if "select *" not in s else 0.0
+
+    feedback = " ".join(fb) if fb else "Perfect optimisation across all four dimensions!"
+    return GraderResult(
+        score=round(min(max(total, 0.0), 1.0), 3),
+        correctness=round(correctness, 3),
+        performance=round(performance, 3),
+        style=round(style, 3),
+        feedback=feedback,
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Registry
+# ──────────────────────────────────────────────────────────────────────────────
+
+TASKS: Dict[int, TaskDef] = {
+    1: TaskDef(
+        id=1,
+        name="fix-broken-join",
+        difficulty="easy",
+        description=_T1_DESC,
+        query=_T1_QUERY.strip(),
+        schema_context=_T1_SCHEMA.strip(),
+        hint="Replace the comma-separated FROM list with an explicit INNER JOIN … ON.",
+        max_steps=3,
+        grader=_grade_task1,
+    ),
+    2: TaskDef(
+        id=2,
+        name="eliminate-n-plus-one",
+        difficulty="medium",
+        description=_T2_DESC,
+        query=_T2_QUERY.strip(),
+        schema_context=_T2_SCHEMA.strip(),
+        hint="Move the subquery out of the SELECT list and into a LEFT JOIN.",
+        max_steps=4,
+        grader=_grade_task2,
+    ),
+    3: TaskDef(
+        id=3,
+        name="full-optimization",
+        difficulty="hard",
+        description=_T3_DESC,
+        query=_T3_QUERY.strip(),
+        schema_context=_T3_SCHEMA.strip(),
+        hint=None,
+        max_steps=5,
+        grader=_grade_task3,
+    ),
+}
+
+
+def get_task(task_id: int) -> TaskDef:
+    if task_id not in TASKS:
+        raise ValueError(f"Unknown task_id {task_id}. Valid: {list(TASKS.keys())}")
+    return TASKS[task_id]

hf_login.py

@@ -0,0 +1,36 @@
+"""
+Interactive HuggingFace login script
+Usage: python hf_login.py
+"""
+from huggingface_hub import login
+import os
+
+print("=" * 60)
+print("HuggingFace Hub Login")
+print("=" * 60)
+print("\nYou can authenticate in two ways:")
+print("1. Enter your API token interactively")
+print("2. Set HF_TOKEN environment variable and run with --auto flag")
+print("\nTo get a token, visit: https://huggingface.co/settings/tokens")
+print("=" * 60)
+
+token = os.getenv("HF_TOKEN", "").strip()
+
+if token:
+    print(f"\nUsing token from HF_TOKEN environment variable...")
+    try:
+        login(token=token)
+        print("✓ Login successful!")
+    except Exception as e:
+        print(f"✗ Login failed: {e}")
+else:
+    print("\nEnter your HuggingFace token (or type 'quit' to exit):")
+    token = input("> ").strip()
+    if token.lower() != 'quit':
+        try:
+            login(token=token)
+            print("✓ Login successful!")
+        except Exception as e:
+            print(f"✗ Login failed: {e}")
+    else:
+        print("Login cancelled.")

jj.txt

@@ -0,0 +1 @@
+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

models.py

@@ -0,0 +1,4 @@
+"""Top-level model exports for OpenEnv validation compatibility."""
+from env.models import Action, Observation, Reward, RewardBreakdown
+
+__all__ = ["Action", "Observation", "Reward", "RewardBreakdown"]

openenv.yaml

@@ -0,0 +1,83 @@
+name: sql-query-optimizer
+version: "1.0.0"
+description: >
+  An OpenEnv environment where AI agents learn to review, rewrite, and optimise
+  SQL queries for correctness and performance. Covers three real-world failure
+  patterns: implicit cross-joins, N+1 subqueries, and multi-dimensional query
+  anti-patterns.
+author: metaXscaler
+tags:
+  - openenv
+  - sql
+  - code-review
+  - data-engineering
+  - database
+tasks:
+  - id: 1
+    name: fix-broken-join
+    difficulty: easy
+    description: >
+      The agent must replace an implicit cross-join (comma syntax) with an
+      explicit INNER JOIN ... ON clause.
+  - id: 2
+    name: eliminate-n-plus-one
+    difficulty: medium
+    description: >
+      The agent must remove a correlated scalar subquery in the SELECT list
+      and replace it with a single LEFT JOIN.
+  - id: 3
+    name: full-optimization
+    difficulty: hard
+    description: >
+      The agent must fix four independent issues: remove redundant DISTINCT,
+      replace SELECT *, eliminate a non-sargable CAST predicate, and add an
+      index hint comment.
+observation:
+  type: object
+  fields:
+    task_id: integer
+    task_name: string
+    task_description: string
+    query: string
+    schema_context: string
+    hint: "string | null"
+    step_number: integer
+    max_steps: integer
+    done: boolean
+action:
+  type: object
+  fields:
+    rewritten_query: string
+    explanation: string
+    is_done: boolean
+reward:
+  type: object
+  fields:
+    score: "float [0.0, 1.0]"
+    grader_score: "float [0.0, 1.0]"
+    breakdown:
+      correctness: "float [0.0, 1.0]"
+      performance: "float [0.0, 1.0]"
+      style: "float [0.0, 1.0]"
+      step_penalty: "float ≤ 0.0"
+    feedback: string
+    cumulative_score: "float [0.0, 1.0]"
+endpoints:
+  - path: /reset
+    method: POST
+    description: Start a fresh episode for a given task_id
+  - path: /step
+    method: POST
+    description: Submit an Action and advance the episode
+  - path: /state
+    method: GET
+    description: Return the current internal state snapshot
+  - path: /tasks
+    method: GET
+    description: List all tasks and action schema
+  - path: /grader
+    method: GET
+    description: Return grader score for the last completed episode
+  - path: /baseline
+    method: POST
+    description: Trigger baseline inference on all 3 tasks

pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sql-query-optimizer-openenv"
+version = "1.0.0"
+description = "An OpenEnv environment where AI agents learn to review, rewrite, and optimise SQL queries for correctness and performance."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    {name = "metaXscaler", email = ""}
+]
+license = {text = "MIT"}
+keywords = ["openenv", "sql", "optimization", "ml", "agent", "environment"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+    "fastapi>=0.111.0",
+    "uvicorn[standard]>=0.29.0",
+    "pydantic>=2.7.0",
+    "openai>=1.30.0",
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "black>=23.0",
+    "ruff>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://huggingface.co/spaces"
+Repository = "https://github.com/metaXscaler/sql-query-optimizer-openenv"
+Documentation = "https://github.com/metaXscaler/sql-query-optimizer-openenv/blob/main/README.md"
+
+[tool.black]
+line-length = 100
+target-version = ['py310', 'py311', 'py312']
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = ["E", "F", "W"]
+ignore = ["E501"]  # Line too long (handled by black)
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]

requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.111.0
+uvicorn[standard]>=0.29.0
+pydantic>=2.7.0
+openai>=1.30.0
+pyyaml>=6.0

server/__init__.py

@@ -0,0 +1,4 @@
+"""FastAPI server package for SQL Query Optimizer OpenEnv environment."""
+from .app import app
+
+__all__ = ["app"]

server/app.py

@@ -0,0 +1,176 @@
+"""
+FastAPI server exposing the OpenEnv SQL Optimizer environment.
+
+Endpoints:
+  POST /reset        → Observation
+  POST /step         → {observation, reward, done, info}
+  GET  /state        → state dict
+  GET  /tasks        → list of tasks + action schema
+  GET  /grader       → grader score for last completed episode
+  POST /baseline     → trigger baseline inference on all 3 tasks
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from env.environment import SQLOptimizerEnv
+from env.models import Action, Observation, Reward
+from env.tasks import TASKS
+
+app = FastAPI(
+    title="SQL Query Optimizer — OpenEnv",
+    description=(
+        "An OpenEnv-compliant environment where AI agents learn to rewrite "
+        "and optimise SQL queries across three difficulty levels."
+    ),
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Single shared environment instance (stateful, per-process)
+_env = SQLOptimizerEnv()
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Request / Response schemas
+# ──────────────────────────────────────────────────────────────────────────────
+
+class ResetRequest(BaseModel):
+    task_id: int = 1
+
+
+class StepResponse(BaseModel):
+    observation: Observation
+    reward: Reward
+    done: bool
+    info: Dict[str, Any]
+
+
+class GraderResponse(BaseModel):
+    task_id: Optional[int]
+    grader_score: float
+    cumulative_score: float
+    done: bool
+
+
+class TaskInfo(BaseModel):
+    id: int
+    name: str
+    difficulty: str
+    description: str
+    action_schema: Dict[str, Any]
+
+
+class BaselineResponse(BaseModel):
+    task_results: Dict[str, float]
+    message: str
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Endpoints
+# ──────────────────────────────────────────────────────────────────────────────
+
+@app.get("/", summary="Health check")
+def health() -> Dict[str, str]:
+    return {"status": "ok", "environment": "sql-query-optimizer", "version": "1.0.0"}
+
+
+@app.post("/reset", response_model=Observation, summary="Start / restart an episode")
+def reset(req: ResetRequest) -> Observation:
+    """Reset the environment for a given task_id (1=easy, 2=medium, 3=hard)."""
+    try:
+        obs = _env.reset(task_id=req.task_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return obs
+
+
+@app.post("/step", response_model=StepResponse, summary="Submit an action")
+def step(action: Action) -> StepResponse:
+    """Advance the environment by submitting an Action."""
+    try:
+        obs, reward, done, info = _env.step(action)
+    except RuntimeError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return StepResponse(observation=obs, reward=reward, done=done, info=info)
+
+
+@app.get("/state", summary="Return current internal state")
+def state() -> Dict[str, Any]:
+    """Return the current internal state of the environment."""
+    return _env.state()
+
+
+@app.get("/tasks", response_model=list[TaskInfo], summary="List tasks + action schema")
+def list_tasks() -> list[TaskInfo]:
+    """Return all tasks with descriptions and the action schema."""
+    action_schema = Action.model_json_schema()
+    return [
+        TaskInfo(
+            id=t.id,
+            name=t.name,
+            difficulty=t.difficulty,
+            description=t.description,
+            action_schema=action_schema,
+        )
+        for t in TASKS.values()
+    ]
+
+
+@app.get("/grader", response_model=GraderResponse, summary="Grader score for last episode")
+def grader() -> GraderResponse:
+    """Return the grader score after the current/last episode."""
+    s = _env.state()
+    if s.get("status") == "not_started":
+        raise HTTPException(status_code=400, detail="No episode started. Call /reset first.")
+    return GraderResponse(
+        task_id=s.get("task_id"),
+        grader_score=s.get("last_grader_score", 0.0),
+        cumulative_score=s.get("cumulative_score", 0.0),
+        done=s.get("done", False),
+    )
+
+
+@app.post("/baseline", response_model=BaselineResponse, summary="Run baseline inference on all tasks")
+def baseline() -> BaselineResponse:
+    """
+    Trigger the baseline inference script (baseline.py) and return scores.
+    Requires OPENAI_API_KEY to be set in the environment.
+    """
+    if not os.getenv("OPENAI_API_KEY"):
+        raise HTTPException(
+            status_code=400,
+            detail="OPENAI_API_KEY environment variable not set. Cannot run baseline.",
+        )
+    try:
+        result = subprocess.run(
+            [sys.executable, "baseline.py", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+        if result.returncode != 0:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Baseline script failed:\n{result.stderr}",
+            )
+        import json
+        scores = json.loads(result.stdout)
+        return BaselineResponse(task_results=scores, message="Baseline completed successfully.")
+    except subprocess.TimeoutExpired:
+        raise HTTPException(status_code=500, detail="Baseline script timed out after 300s.")
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=str(exc))

sql-query-optimizer/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

sql-query-optimizer/README.md

@@ -0,0 +1,12 @@
+---
+title: Sql Query Optimizer
+emoji: 🚀
+colorFrom: purple
+colorTo: gray
+sdk: docker
+pinned: false
+license: mit
+short_description: SQL Query Optimizer — OpenEnv Environment
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

test_env.py

@@ -0,0 +1,86 @@
+"""Quick smoke test for all 3 tasks."""
+import sys, json
+sys.path.insert(0, ".")
+
+from env.environment import SQLOptimizerEnv
+from env.models import Action
+
+env = SQLOptimizerEnv()
+
+# ── Task 1 ──────────────────────────────────────────────────────────────────
+print("=== Task 1 (Easy): fix-broken-join ===")
+obs = env.reset(1)
+print(f"  task: {obs.task_name}")
+action = Action(
+    rewritten_query=(
+        "SELECT o.order_id, c.name, o.total "
+        "FROM orders o INNER JOIN customers c ON o.customer_id = c.customer_id "
+        "WHERE o.total > 100"
+    ),
+    explanation="Replaced comma cross-join with INNER JOIN ON customer_id",
+    is_done=True,
+)
+obs2, reward, done, info = env.step(action)
+print(f"  grader_score={info['grader_score']:.3f}  step_reward={reward.score:.4f}  done={done}")
+print(f"  feedback: {reward.feedback}")
+assert obs2.done == True, "done should be True"
+assert info["grader_score"] >= 0.8, f"Expected >=0.8, got {info['grader_score']}"
+
+# ── Task 2 ──────────────────────────────────────────────────────────────────
+print()
+print("=== Task 2 (Medium): eliminate-n-plus-one ===")
+obs = env.reset(2)
+print(f"  task: {obs.task_name}")
+action = Action(
+    rewritten_query=(
+        "SELECT e.name, d.dept_name "
+        "FROM employees e "
+        "LEFT JOIN departments d ON e.dept_id = d.dept_id "
+        "WHERE e.salary > 50000"
+    ),
+    explanation="Replaced correlated subquery with a single LEFT JOIN",
+    is_done=True,
+)
+obs2, reward, done, info = env.step(action)
+print(f"  grader_score={info['grader_score']:.3f}  step_reward={reward.score:.4f}  done={done}")
+print(f"  feedback: {reward.feedback}")
+assert info["grader_score"] >= 0.7, f"Expected >=0.7, got {info['grader_score']}"
+
+# ── Task 3 ──────────────────────────────────────────────────────────────────
+print()
+print("=== Task 3 (Hard): full-optimization ===")
+obs = env.reset(3)
+print(f"  task: {obs.task_name}")
+action = Action(
+    rewritten_query=(
+        "-- Index hint: consider CREATE INDEX ON products(category, price)\n"
+        "SELECT p.name, p.category, p.price, oi.quantity, oi.unit_price\n"
+        "FROM   products p\n"
+        "JOIN   order_items oi ON p.product_id = oi.product_id\n"
+        "WHERE  p.price >= 100 AND p.price < 200\n"
+        "  AND  p.category = 'Electronics'\n"
+        "ORDER  BY p.name"
+    ),
+    explanation="Removed DISTINCT and SELECT *, replaced CAST LIKE with range, added index hint",
+    is_done=True,
+)
+obs2, reward, done, info = env.step(action)
+print(f"  grader_score={info['grader_score']:.3f}  step_reward={reward.score:.4f}  done={done}")
+print(f"  feedback: {reward.feedback}")
+assert info["grader_score"] >= 0.9, f"Expected >=0.9, got {info['grader_score']}"
+
+# ── state() ─────────────────────────────────────────────────────────────────
+print()
+print("=== state() ===")
+print(json.dumps(env.state(), indent=2))
+
+# ── invalid action penalty ───────────────────────────────────────────────────
+print()
+print("=== Invalid action test ===")
+env.reset(1)
+obs2, reward, done, info = env.step(Action(rewritten_query="", explanation="", is_done=False))
+print(f"  step_reward={reward.score}  is_invalid={info['is_invalid']}")
+assert info["is_invalid"] == True, "Empty query should be flagged invalid"
+
+print()
+print("ALL TESTS PASSED")