synth-ai 0.2.4.dev5__py3-none-any.whl → 0.2.4.dev7__py3-none-any.whl

synth_ai/environments/examples/wordle/taskset.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from uuid import UUID
+
+from synth_ai.environments.tasks.core import (
+    Impetus,
+    Intent,
+    SplitInfo,
+    TaskInstance,
+    TaskInstanceMetadata,
+    TaskInstanceSet,
+)
+
+from .engine import DEFAULT_SOLUTIONS
+
+
+@dataclass
+class WordleTaskInstanceMetadata(TaskInstanceMetadata):
+    word_length: int
+    max_guesses: int
+    target_word: str
+    enforce_wordlist: bool
+    seed: int | None = None
+    consume_invalid_attempts: bool = True
+
+
+@dataclass
+class WordleTaskInstance(TaskInstance):
+    async def serialize(self) -> dict:
+        return {
+            "id": str(self.id),
+            "impetus": {"instructions": self.impetus.instructions},
+            "intent": {
+                "rubric": self.intent.rubric,
+                "gold_trajectories": self.intent.gold_trajectories,
+                "gold_state_diff": self.intent.gold_state_diff,
+            },
+            "metadata": {
+                "word_length": self.metadata.word_length,
+                "max_guesses": self.metadata.max_guesses,
+                "target_word": self.metadata.target_word,
+                "enforce_wordlist": self.metadata.enforce_wordlist,
+                "seed": self.metadata.seed,
+                "consume_invalid_attempts": self.metadata.consume_invalid_attempts,
+            },
+            "is_reproducible": self.is_reproducible,
+            "initial_engine_snapshot": self.initial_engine_snapshot,
+        }
+
+    @classmethod
+    async def deserialize(cls, data: dict) -> WordleTaskInstance:
+        from uuid import UUID
+
+        metadata = WordleTaskInstanceMetadata(
+            word_length=data["metadata"]["word_length"],
+            max_guesses=data["metadata"]["max_guesses"],
+            target_word=data["metadata"]["target_word"],
+            enforce_wordlist=data["metadata"]["enforce_wordlist"],
+            seed=data["metadata"].get("seed"),
+            consume_invalid_attempts=data["metadata"].get("consume_invalid_attempts", True),
+        )
+
+        return cls(
+            id=UUID(data["id"]),
+            impetus=Impetus(instructions=data["impetus"]["instructions"]),
+            intent=Intent(
+                rubric=data["intent"]["rubric"],
+                gold_trajectories=data["intent"]["gold_trajectories"],
+                gold_state_diff=data["intent"]["gold_state_diff"],
+            ),
+            metadata=metadata,
+            is_reproducible=data["is_reproducible"],
+            initial_engine_snapshot=data["initial_engine_snapshot"],
+        )
+
+
+def _stable_uuid_for_instance(idx: int, target: str) -> UUID:
+    import uuid
+
+    return uuid.uuid5(uuid.NAMESPACE_URL, f"wordle-fixed-v1:{idx}:{target}")
+
+
+def _load_fixed_instances_json() -> tuple[list[dict], dict]:
+    """Load fixed instances definition from instances.json (if present).
+
+    Returns a tuple (instances, defaults) where instances is a list of dicts with at least
+    target_word fields, and defaults contains default params.
+    """
+    import os
+
+    # Allow override via env var
+    override = os.getenv("WORDLE_INSTANCES_JSON")
+    p = Path(override) if override else Path(__file__).with_name("instances.json")
+    if not p.exists():
+        return [], {}
+    try:
+        data = json.loads(p.read_text())
+        defaults = data.get("defaults", {}) or {}
+        insts = data.get("instances", []) or []
+        return insts, defaults
+    except Exception:
+        return [], {}
+
+
+# Note: generation helpers removed from runtime. Use the provided script in tools/
+_ = None
+
+
+async def create_wordle_taskset(
+    *,
+    word_length: int = 5,
+    max_guesses: int = 6,
+    enforce_wordlist: bool = False,
+    sample_size: int = 30,
+    consume_invalid_attempts: bool = True,
+) -> TaskInstanceSet:
+    """Create a Wordle taskset.
+
+    Priority:
+    1) If instances.json exists, use it to produce a fixed, stable taskset with deterministic IDs.
+    2) Otherwise, fall back to a procedural slice of DEFAULT_SOLUTIONS (stable ordering).
+    """
+
+    json_insts, json_defaults = _load_fixed_instances_json()
+
+    instances: list[WordleTaskInstance] = []
+    # Assemble fixed targets from JSON only (no runtime generation)
+    fixed_targets: list[str] = []
+    if json_insts:
+        fixed_targets.extend(
+            [
+                str(r.get("target_word", "")).strip().lower()
+                for r in json_insts
+                if r.get("target_word")
+            ]
+        )
+
+    if fixed_targets:
+        # Use fixed_targets, honoring defaults and slicing by sample_size
+        chosen = fixed_targets[:sample_size]
+        for i, tgt in enumerate(chosen):
+            md = WordleTaskInstanceMetadata(
+                word_length=int(word_length),
+                max_guesses=int(max_guesses),
+                target_word=tgt,
+                enforce_wordlist=bool(enforce_wordlist),
+                seed=i,
+                consume_invalid_attempts=bool(consume_invalid_attempts),
+            )
+            impetus = Impetus(
+                instructions=(
+                    "Play Wordle. Submit one word per turn consisting only of letters. "
+                    f"You have up to {md.max_guesses} guesses to find the {md.word_length}-letter target word. "
+                    "Feedback per letter: G=correct position, Y=present elsewhere, B=absent."
+                )
+            )
+            intent = Intent(
+                rubric={"goal": "Guess the target word in as few moves as possible"},
+                gold_trajectories=None,
+                gold_state_diff={"target_known": False},
+            )
+            inst = WordleTaskInstance(
+                id=_stable_uuid_for_instance(i, md.target_word),
+                impetus=impetus,
+                intent=intent,
+                metadata=md,
+                is_reproducible=True,
+                initial_engine_snapshot=None,
+            )
+            instances.append(inst)
+    else:
+        # Procedural fallback: stable ordering from DEFAULT_SOLUTIONS
+        pool = [w for w in DEFAULT_SOLUTIONS if len(w) == word_length] or [
+            w for w in DEFAULT_SOLUTIONS if len(w) == 5
+        ]
+        sample = pool[:sample_size]
+        for i, target in enumerate(sample):
+            seed = i
+            md = WordleTaskInstanceMetadata(
+                word_length=word_length,
+                max_guesses=max_guesses,
+                target_word=target,
+                enforce_wordlist=enforce_wordlist,
+                seed=seed,
+                consume_invalid_attempts=consume_invalid_attempts,
+            )
+            impetus = Impetus(
+                instructions=(
+                    "Play Wordle. Submit one word per turn consisting only of letters. "
+                    f"You have up to {max_guesses} guesses to find the {word_length}-letter target word. "
+                    "Feedback per letter: G=correct position, Y=present elsewhere, B=absent."
+                )
+            )
+            intent = Intent(
+                rubric={"goal": "Guess the target word in as few moves as possible"},
+                gold_trajectories=None,
+                gold_state_diff={"target_known": False},
+            )
+            inst = WordleTaskInstance(
+                id=_stable_uuid_for_instance(i, target),
+                impetus=impetus,
+                intent=intent,
+                metadata=md,
+                is_reproducible=True,
+                initial_engine_snapshot=None,
+            )
+            instances.append(inst)
+
+    # Deterministic split based on index positions
+    val_ids = {instances[i].id for i in range(0, len(instances), 5)}
+    test_ids = {instances[i].id for i in range(0, len(instances), 7)}
+    split = SplitInfo(val_instance_ids=val_ids, test_instance_ids=test_ids, _is_split_defined=True)
+
+    return TaskInstanceSet(
+        name="Wordle Fixed TaskSet" if json_insts else "Wordle Example TaskSet",
+        description=(
+            "Fixed set from instances.json (stable ordering)."
+            if json_insts
+            else "Lightweight Wordle tasks with fixed targets and seeds."
+        ),
+        instances=instances,
+        split_info=split,
+    )
+
+
+# Alias
+taskset = create_wordle_taskset

synth_ai/environments/reproducibility/core.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import TypeVar, Generic, Any
+from typing import Any, Generic, TypeVar
 
 
 class IReproducibleEngine(ABC):

synth_ai/environments/reproducibility/tree.py

@@ -13,13 +13,14 @@ big “backend.production” code-base.
 
 from __future__ import annotations
 
-import json
-import sqlite3
 import gzip
-import pickle
+import json
 import logging
+import pickle
+import sqlite3
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Any, Dict, Optional, Tuple, Iterable
+from typing import Any
 
 import networkx as nx
 
@@ -31,10 +32,9 @@ log = logging.getLogger(__name__)
 # --------------------------------------------------------------------------- #
 # lightweight metadata record                                                 #
 # --------------------------------------------------------------------------- #
-import os
 import hashlib
 import logging
-from typing import Union
+import os
 
 log = logging.getLogger(__name__)
 
@@ -51,7 +51,7 @@ class FilesystemSnapshotStore:
     is the SHA-256 hash of its compressed content.
     """
 
-    def __init__(self, base_dir: Union[str, Path] = DEFAULT_SNAPSHOT_DIR):
+    def __init__(self, base_dir: str | Path = DEFAULT_SNAPSHOT_DIR):
         self.base_dir = Path(base_dir)
         try:
             self.base_dir.mkdir(parents=True, exist_ok=True)
@@ -69,7 +69,7 @@ class FilesystemSnapshotStore:
         filename = f"{key}.snapshot.gz"
         return self.base_dir / filename
 
-    def write(self, blob: Union[bytes, Dict[str, Any]]) -> str:
+    def write(self, blob: bytes | dict[str, Any]) -> str:
         """
         Stores a snapshot blob (bytes or dict) and returns its SHA-256 key.
 
@@ -95,7 +95,7 @@ class FilesystemSnapshotStore:
             log.error(f"Failed to write snapshot: {e}", exc_info=True)
             raise
 
-    def read(self, key: str) -> Optional[bytes]:
+    def read(self, key: str) -> bytes | None:
         """
         Retrieves the raw *compressed* snapshot bytes for a given key.
 
@@ -143,12 +143,12 @@ class TrajectorySnapshot:
     def __init__(
         self,
         snap_id: str,
-        parent_id: Optional[str],
+        parent_id: str | None,
         depth: int,
-        action: Optional[Any],
+        action: Any | None,
         reward: float = 0.0,
         terminated: bool = False,
-        info: Optional[Dict[str, Any]] = None,
+        info: dict[str, Any] | None = None,
     ):
         self.snap_id = snap_id
         self.parent_id = parent_id
@@ -186,9 +186,9 @@ class TrajectoryTreeStore:
 
     def __init__(
         self,
-        snapshot_store: Optional[FilesystemSnapshotStore] = None,
+        snapshot_store: FilesystemSnapshotStore | None = None,
         *,
-        db_path: Optional[Path | str] = None,
+        db_path: Path | str | None = None,
     ):
         self.snap_store = snapshot_store or FilesystemSnapshotStore()
         self.graph: nx.DiGraph = nx.DiGraph()
@@ -202,7 +202,7 @@ class TrajectoryTreeStore:
 
     # insertion -------------------------------------------------------------
 
-    def add_root(self, snapshot_blob: bytes, *, info: Dict[str, Any] | None = None) -> str:
+    def add_root(self, snapshot_blob: bytes, *, info: dict[str, Any] | None = None) -> str:
         """Insert the very first node and return its content-hash key."""
         snap_id = self.snap_store.write(snapshot_blob)
         self._add_node(TrajectorySnapshot(snap_id, None, 0, None, 0.0, False, info))
@@ -216,7 +216,7 @@ class TrajectoryTreeStore:
         action: Any,
         reward: float,
         terminated: bool = False,
-        info: Dict[str, Any] | None = None,
+        info: dict[str, Any] | None = None,
     ) -> str:
         """Attach `snapshot_blob` as a child reached by `action` from *parent_id*."""
         if parent_id not in self.graph:
@@ -230,10 +230,10 @@ class TrajectoryTreeStore:
 
     # read-side helpers -----------------------------------------------------
 
-    def get_children(self, snap_id: str) -> Tuple[str, ...]:
+    def get_children(self, snap_id: str) -> tuple[str, ...]:
         return tuple(self.graph.successors(snap_id))
 
-    def get_parent(self, snap_id: str) -> Optional[str]:
+    def get_parent(self, snap_id: str) -> str | None:
         preds = tuple(self.graph.predecessors(snap_id))
         return preds[0] if preds else None
 
@@ -246,17 +246,17 @@ class TrajectoryTreeStore:
         """Yield snapshot-ids that currently have no children."""
         return (n for n in self.graph.nodes if self.is_leaf(n))
 
-    def path_to_root(self, snap_id: str) -> Tuple[str, ...]:
+    def path_to_root(self, snap_id: str) -> tuple[str, ...]:
         """Return (snap_id, …, root_id)"""
         path = [snap_id]
         while (p := self.get_parent(path[-1])) is not None:
             path.append(p)
         return tuple(path)
 
-    def reconstruct_actions(self, snap_id: str) -> Tuple[Any, ...]:
+    def reconstruct_actions(self, snap_id: str) -> tuple[Any, ...]:
         """Return the sequence of *actions* from the root → `snap_id`."""
         actions = []
-        for child, parent in zip(self.path_to_root(snap_id)[:-1], self.path_to_root(snap_id)[1:]):
+        for child, parent in zip(self.path_to_root(snap_id)[:-1], self.path_to_root(snap_id)[1:], strict=False):
             actions.append(self.graph.edges[parent, child]["action"])
         return tuple(reversed(actions))
 

synth_ai/environments/service/app.py

@@ -1,5 +1,5 @@
-import sys
 import os  # Added to ensure os is available before use
+import sys
 
 # Ensure local 'src' directory is on PYTHONPATH for dev installs
 # Current file: <repo>/src/synth_env/service/app.py
@@ -12,12 +12,12 @@ print(f"SYS.PATH IN APP.PY: {sys.path}")
 import logging
 
 from fastapi import FastAPI
-from synth_ai.environments.service.registry import list_supported_env_types, register_environment
 from synth_ai.environments.service.core_routes import api_router
 from synth_ai.environments.service.external_registry import (
     ExternalRegistryConfig,
     load_external_environments,
 )
+from synth_ai.environments.service.registry import list_supported_env_types, register_environment
 
 # Configure logging with more detail
 logging.basicConfig(
@@ -38,6 +38,15 @@ import synth_ai.environments.examples.crafter_custom.environment as ccustom
 
 register_environment("CrafterCustom", ccustom.CrafterCustomEnvironment)
 
+# Register Wordle example environment
+try:
+    import synth_ai.environments.examples.wordle.environment as wordle_mod
+
+    register_environment("Wordle", wordle_mod.WordleEnvironment)
+except Exception as _e:
+    # Keep service robust even if example env import fails
+    logging.getLogger(__name__).warning(f"Wordle env not registered: {_e}")
+
 app = FastAPI(title="Environment Service")