Make manual seed input affect visible output

cleanops_env/environment.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import copy
+import random
 from uuid import uuid4
 
 from openenv.core.env_server.interfaces import Environment
@@ -50,6 +52,7 @@ class CleanOpsEnvironment(Environment[DataCleaningAction, DataCleaningObservatio
             task_id=self._task_spec.task_id,
             task_title=self._task_spec.title,
             difficulty=self._task_spec.difficulty,
+            requested_seed=None,
             max_steps=self._task_spec.max_steps,
             submitted=False,
             current_score=self._grade.score,
@@ -69,10 +72,11 @@ class CleanOpsEnvironment(Environment[DataCleaningAction, DataCleaningObservatio
         task_id: str | None = None,
         **kwargs: object,
     ) -> DataCleaningObservation:
-        del seed, kwargs
+        del kwargs
         selected_task_id = task_id or self._task_order[0]
         self._task_spec = get_task_spec(selected_task_id)
-        self._focus_table_name = first_table_name(self._task_spec)
+        normalized_seed = seed if seed is None else max(0, int(seed))
+        self._focus_table_name = self._choose_initial_focus_table(self._task_spec, normalized_seed)
         self._focus_operation_detail = None
         self._done = False
         self._grade = grade_tables(self._task_spec, self._task_spec.dirty_tables)
@@ -83,6 +87,7 @@ class CleanOpsEnvironment(Environment[DataCleaningAction, DataCleaningObservatio
             task_id=self._task_spec.task_id,
             task_title=self._task_spec.title,
             difficulty=self._task_spec.difficulty,
+            requested_seed=normalized_seed,
             max_steps=self._task_spec.max_steps,
             submitted=False,
             current_score=self._grade.score,
@@ -92,7 +97,7 @@ class CleanOpsEnvironment(Environment[DataCleaningAction, DataCleaningObservatio
             applied_operation_ids=[],
             inspected_tables=[self._focus_table_name],
             inspected_operations=[],
-            recent_history=[f"reset -> loaded task {self._task_spec.task_id} ({self._task_spec.difficulty})"],
+            recent_history=[f"reset -> loaded task {self._task_spec.task_id} ({self._task_spec.difficulty}) seed={normalized_seed}"],
         )
         return self._build_observation(
             reward_breakdown=RewardBreakdown(total=0.0),
@@ -273,6 +278,7 @@ class CleanOpsEnvironment(Environment[DataCleaningAction, DataCleaningObservatio
             task_id=self._task_spec.task_id,
             task_title=self._task_spec.title,
             difficulty=self._task_spec.difficulty,
+            requested_seed=self._state.requested_seed,
             objective=self._task_spec.objective,
             dataset_context=self._task_spec.dataset_context,
             quality_score=self._state.current_score,
@@ -293,6 +299,7 @@ class CleanOpsEnvironment(Environment[DataCleaningAction, DataCleaningObservatio
             done=done,
             metadata={
                 "episode_id": self._state.episode_id,
+                "requested_seed": self._state.requested_seed,
                 "applied_operation_ids": list(self._state.applied_operation_ids),
                 "submitted": self._state.submitted,
             },
@@ -300,10 +307,33 @@ class CleanOpsEnvironment(Environment[DataCleaningAction, DataCleaningObservatio
 
     def _build_table_view(self, task_spec: TaskSpec, table_name: str) -> TableView:
         primary_key = task_spec.primary_keys[table_name]
-        rows = sorted_rows(self._state.tables.get(table_name, []), primary_key)
+        rows = self._preview_rows(task_spec, table_name, self._state.tables.get(table_name, []))
         columns = sorted({column_name for row in rows for column_name in row})
         return TableView(name=table_name, primary_key=primary_key, columns=columns, rows=rows)
 
+    def _choose_initial_focus_table(self, task_spec: TaskSpec, seed: int | None) -> str:
+        table_names = sorted(task_spec.dirty_tables)
+        if not table_names:
+            return first_table_name(task_spec)
+        if seed is None:
+            return table_names[0]
+        return table_names[seed % len(table_names)]
+
+    def _preview_rows(
+        self,
+        task_spec: TaskSpec,
+        table_name: str,
+        rows: list[dict[str, str]],
+    ) -> list[dict[str, str]]:
+        primary_key = task_spec.primary_keys[table_name]
+        ordered_rows = sorted_rows(rows, primary_key)
+        seed = self._state.requested_seed
+        if seed is None or len(ordered_rows) <= 1:
+            return ordered_rows
+        shuffled_rows = copy.deepcopy(ordered_rows)
+        random.Random(seed + sum(ord(char) for char in table_name)).shuffle(shuffled_rows)
+        return shuffled_rows
+
     def _build_operation_detail(
         self,
         task_spec: TaskSpec,

cleanops_env/models.py

@@ -114,6 +114,7 @@ class DataCleaningObservation(Observation):
     task_id: str = Field(..., description="Current task identifier.")
     task_title: str = Field(..., description="Human-readable task title.")
     difficulty: Literal["easy", "medium", "hard"] = Field(..., description="Task difficulty.")
+    requested_seed: int | None = Field(default=None, description="Seed used when resetting the current episode.")
     objective: str = Field(..., description="Concrete task objective.")
     dataset_context: str = Field(..., description="Why this dataset exists in the real world.")
     quality_score: float = Field(default=0.0, description="Current deterministic grader score.")
@@ -138,6 +139,7 @@ class DataCleaningState(State):
     task_id: str = Field(..., description="Current task identifier.")
     task_title: str = Field(..., description="Current task title.")
     difficulty: Literal["easy", "medium", "hard"] = Field(..., description="Current task difficulty.")
+    requested_seed: int | None = Field(default=None, description="Seed used when resetting the current episode.")
     max_steps: int = Field(..., description="Task step budget.")
     submitted: bool = Field(default=False, description="Whether submit was called.")
     current_score: float = Field(default=0.0, description="Current deterministic grader score.")

server/app.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+import copy
+import random
+
 from openenv.core import create_app
 from fastapi.responses import HTMLResponse, JSONResponse
 
@@ -20,18 +23,19 @@ app = create_app(
 
 
 @app.get("/demo/compare", include_in_schema=False)
-def demo_compare(task_id: str = "customer_contacts_easy", table_name: str | None = None) -> JSONResponse:
+def demo_compare(task_id: str = "customer_contacts_easy", table_name: str | None = None, seed: int | None = None) -> JSONResponse:
     task_spec = get_task_spec(task_id)
     selected_table = table_name if table_name in task_spec.dirty_tables else first_table_name(task_spec)
     primary_key = task_spec.primary_keys[selected_table]
-    before_rows = sorted_rows(task_spec.dirty_tables[selected_table], primary_key)
-    after_rows = sorted_rows(task_spec.gold_tables[selected_table], primary_key)
+    before_rows = _seed_preview_rows(task_spec.dirty_tables[selected_table], primary_key, selected_table, seed)
+    after_rows = _seed_preview_rows(task_spec.gold_tables[selected_table], primary_key, selected_table, seed)
     columns = sorted({column_name for row in before_rows + after_rows for column_name in row})
     return JSONResponse(
         {
             "task_id": task_spec.task_id,
             "task_title": task_spec.title,
             "table_name": selected_table,
+            "requested_seed": seed,
             "available_tables": list(task_spec.dirty_tables.keys()),
             "columns": columns,
             "before_rows": before_rows[:4],
@@ -43,6 +47,20 @@ def demo_compare(task_id: str = "customer_contacts_easy", table_name: str | None
     )
 
 
+def _seed_preview_rows(
+    rows: list[dict[str, str]],
+    primary_key: str,
+    table_name: str,
+    seed: int | None,
+) -> list[dict[str, str]]:
+    ordered_rows = sorted_rows(rows, primary_key)
+    if seed is None or len(ordered_rows) <= 1:
+        return ordered_rows
+    shuffled_rows = copy.deepcopy(ordered_rows)
+    random.Random(max(0, int(seed)) + sum(ord(char) for char in table_name)).shuffle(shuffled_rows)
+    return shuffled_rows
+
+
 @app.get("/", include_in_schema=False)
 def root() -> HTMLResponse:
     return HTMLResponse(
@@ -718,7 +736,7 @@ def root() -> HTMLResponse:
                   <p>
                     The cards and table below are populated from a real
                     <code>POST /reset</code> response. Use the task buttons above to
-                    switch between benchmark scenarios.
+                    switch between benchmark scenarios, or choose your own task and seed.
                   </p>
 
                   <div class="kpis">
@@ -1039,12 +1057,12 @@ def root() -> HTMLResponse:
                   const rows = (observation.focus_table?.rows || []).slice(0, 4);
                   renderTable(columns, rows);
 
-                  const compareResponse = await fetch(`/demo/compare?task_id=${encodeURIComponent(taskId)}&table_name=${encodeURIComponent(observation.focus_table?.name || "")}`);
+                  const compareResponse = await fetch(`/demo/compare?task_id=${encodeURIComponent(taskId)}&table_name=${encodeURIComponent(observation.focus_table?.name || "")}&seed=${encodeURIComponent(String(seed))}`);
                   if (!compareResponse.ok) {
                     throw new Error(`Compare HTTP ${compareResponse.status}`);
                   }
                   const comparePayload = await compareResponse.json();
-                  compareMetaEl.textContent = `${comparePayload.task_title} • table: ${comparePayload.table_name}`;
+                  compareMetaEl.textContent = `${comparePayload.task_title} • table: ${comparePayload.table_name} • seed: ${comparePayload.requested_seed ?? seed}`;
                   beforeMetaEl.textContent = `${comparePayload.before_row_count} rows`;
                   afterMetaEl.textContent = `${comparePayload.after_row_count} rows`;
                   renderTableTo(beforeHeadRowEl, beforeBodyEl, comparePayload.columns || [], comparePayload.before_rows || []);
@@ -1056,6 +1074,7 @@ def root() -> HTMLResponse:
                   outputEl.textContent = JSON.stringify(
                     {
                       task_id: observation.task_id,
+                      requested_seed: observation.requested_seed ?? seed,
                       difficulty: observation.difficulty,
                       objective: observation.objective,
                       quality_score: observation.quality_score,
@@ -1067,7 +1086,7 @@ def root() -> HTMLResponse:
                     null,
                     2
                   );
-                  setRunFeedback("success", `Loaded ${observation.task_title || taskId} successfully.`);
+                  setRunFeedback("success", `Loaded ${observation.task_title || taskId} successfully with seed ${observation.requested_seed ?? seed}.`);
                 } catch (error) {
                   outputEl.textContent = `Request failed: ${error.message}`;
                   objectiveEl.textContent = "Request failed.";

tests/test_environment.py

@@ -10,6 +10,7 @@ def test_reset_step_state_api() -> None:
     env = LocalCleanOpsEnv()
     observation = env.reset(task_id="customer_contacts_easy", seed=7)
     assert observation.task_id == "customer_contacts_easy"
+    assert observation.requested_seed == 7
     assert observation.done is False
     assert observation.quality_score < 1.0
 
@@ -45,3 +46,16 @@ def test_decoy_operation_lowers_easy_task_quality() -> None:
     damaged_grade = grade_tables(task_spec, damaged_tables)
     assert clean_grade.score == 1.0
     assert damaged_grade.score < clean_grade.score
+
+
+def test_seed_changes_visible_preview_rows() -> None:
+    env = LocalCleanOpsEnv()
+    observation_seed_2 = env.reset(task_id="customer_contacts_easy", seed=2)
+    preview_seed_2 = [row["customer_id"] for row in observation_seed_2.focus_table.rows[:4]]
+
+    observation_seed_7 = env.reset(task_id="customer_contacts_easy", seed=7)
+    preview_seed_7 = [row["customer_id"] for row in observation_seed_7.focus_table.rows[:4]]
+
+    assert observation_seed_2.requested_seed == 2
+    assert observation_seed_7.requested_seed == 7
+    assert preview_seed_2 != preview_seed_7