synth-ai 0.2.14__py3-none-any.whl → 0.4.4__py3-none-any.whl

synth_ai/environments/examples/wordle/taskset.py

@@ -1,230 +0,0 @@
-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,42 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Generic, TypeVar
-
-
-class IReproducibleEngine(ABC):
-    """
-    An abstract base class for engines that support serialization and deserialization,
-    making them reproducible.
-    """
-
-    @abstractmethod
-    async def _serialize_engine(
-        self,
-    ) -> Any:  # Replace Any with a more specific Snapshot type if common one emerges
-        """Serializes the current state of the engine."""
-        pass
-
-    @classmethod
-    @abstractmethod
-    async def _deserialize_engine(cls, snapshot: Any) -> "IReproducibleEngine":  # Replace Any
-        """Creates an engine instance from a serialized snapshot."""
-        pass
-
-
-# Type variable for the engine, ensuring it adheres to the IReproducibleEngine interface.
-EngineType_co = TypeVar("EngineType_co", bound=IReproducibleEngine, covariant=True)
-
-
-class ReproducibleEnvironment(Generic[EngineType_co]):
-    """
-    A mixin class for environments that support reproducibility through
-    engine serialization and deserialization.
-
-    It expects the environment to have an 'engine' attribute that conforms to
-    the IReproducibleEngine interface. This contract is enforced via type hinting
-    and the IReproducibleEngine ABC.
-    """
-
-    engine: EngineType_co
-    # No explicit runtime checks like hasattr are performed here.
-    # The presence and correctness of _serialize_engine and _deserialize_engine
-    # methods on the engine are ensured by the IReproducibleEngine contract.

synth_ai/environments/reproducibility/tree.py

@@ -1,363 +0,0 @@
-"""
-NOTE - first pass was o3-generated. Mostly bc idrk what I 'want' from this yet ...
-trajectory_tree_store.py
-~~~~~~~~~~~~~~~~~~~~~~~~
-A minimal search-tree wrapper that pairs
-
-  • an *in-memory* NetworkX DiGraph (parent ⇢ children edges)
-  • a *content-addressable* FilesystemSnapshotStore (heavy blobs)
-
-so you can implement things like LATS / MCTS without bringing in the
-big “backend.production” code-base.
-"""
-
-from __future__ import annotations
-
-import gzip
-import hashlib
-import json
-import logging
-import os
-import pickle
-import sqlite3
-from collections.abc import Iterable
-from pathlib import Path
-from typing import Any
-
-import networkx as nx
-
-# from filesystem_snapshot_store import FilesystemSnapshotStore  # ← your re-impl
-
-log = logging.getLogger(__name__)
-
-
-# --------------------------------------------------------------------------- #
-# lightweight metadata record                                                 #
-# --------------------------------------------------------------------------- #
-
-# Default directory for storing snapshots relative to some base path
-# This could be configured via environment variables or settings later.
-DEFAULT_SNAPSHOT_DIR = Path(os.getenv("SNAPSHOT_STORE_PATH", "/tmp/agent_snapshots"))
-
-
-class FilesystemSnapshotStore:
-    """
-    Stores and retrieves environment state snapshots on the filesystem.
-
-    Uses content-addressable storage: the key (ID) for a snapshot
-    is the SHA-256 hash of its compressed content.
-    """
-
-    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)
-            log.info(f"Initialized snapshot store at: {self.base_dir}")
-        except OSError as e:
-            log.error(
-                f"Failed to create snapshot directory {self.base_dir}: {e}",
-                exc_info=True,
-            )
-            raise
-
-    def _get_path(self, key: str) -> Path:
-        """Constructs the full path for a given snapshot key."""
-        # Maybe add subdirectories later for large numbers of files, e.g., key[:2]/key[2:]
-        filename = f"{key}.snapshot.gz"
-        return self.base_dir / filename
-
-    def write(self, blob: bytes | dict[str, Any]) -> str:
-        """
-        Stores a snapshot blob (bytes or dict) and returns its SHA-256 key.
-
-        • Dicts → pickle → gzip
-        • Bytes already gzip-compressed (magic 0x1f 0x8b) are stored as-is
-          to avoid double compression.
-        """
-        try:
-            if isinstance(blob, dict):
-                compressed_blob = gzip.compress(pickle.dumps(blob))
-            elif isinstance(blob, bytes):
-                # Skip re-compression if data is already gzipped
-                compressed_blob = blob if blob[:2] == b"\x1f\x8b" else gzip.compress(blob)
-            else:
-                raise TypeError(f"Unsupported blob type for snapshot store: {type(blob)}")
-
-            key = hashlib.sha256(compressed_blob).hexdigest()
-            path = self._get_path(key)
-            if not path.exists():
-                path.write_bytes(compressed_blob)
-            return key
-        except Exception as e:
-            log.error(f"Failed to write snapshot: {e}", exc_info=True)
-            raise
-
-    def read(self, key: str) -> bytes | None:
-        """
-        Retrieves the raw *compressed* snapshot bytes for a given key.
-
-        Returns None if the key is not found.
-        Deserialization (decompression, unpickling) is the responsibility
-        of the caller (e.g., ReproducibleResource.from_snapshot).
-        """
-        filepath = self._get_path(key)
-        if not filepath.exists():
-            log.warning(f"Snapshot key not found: {key}")
-            return None
-        try:
-            with open(filepath, "rb") as f:
-                compressed_blob = f.read()
-            return compressed_blob
-        except OSError as e:
-            log.error(f"Failed to read snapshot {key} from {filepath}: {e}", exc_info=True)
-            return None  # Or re-raise? Returning None might be safer.
-
-    def exists(self, key: str) -> bool:
-        """Checks if a snapshot with the given key exists."""
-        return self._get_path(key).exists()
-
-
-# Global instance (optional, could use dependency injection)
-# snapshot_store = FilesystemSnapshotStore()
-
-
-class TrajectorySnapshot:
-    """
-    A *metadata* header for one node in the search tree.
-    The heavy serialized-state bytes live only in the snapshot store.
-    """
-
-    __slots__ = (
-        "snap_id",
-        "parent_id",
-        "depth",
-        "action",
-        "reward",
-        "terminated",
-        "info",
-    )
-
-    def __init__(
-        self,
-        snap_id: str,
-        parent_id: str | None,
-        depth: int,
-        action: Any | None,
-        reward: float = 0.0,
-        terminated: bool = False,
-        info: dict[str, Any] | None = None,
-    ):
-        self.snap_id = snap_id
-        self.parent_id = parent_id
-        self.depth = depth
-        self.action = action
-        self.reward = reward
-        self.terminated = bool(terminated)
-        self.info = info or {}
-
-    # helpful for printing / debugging
-    def __repr__(self) -> str:  # pragma: no cover
-        a = json.dumps(self.action) if self.action is not None else "∅"
-        return (
-            f"TrajSnap(id={self.snap_id[:7]}…, depth={self.depth}, "
-            f"action={a}, reward={self.reward}, term={self.terminated})"
-        )
-
-
-# --------------------------------------------------------------------------- #
-# tree manager                                                                #
-# --------------------------------------------------------------------------- #
-
-
-class TrajectoryTreeStore:
-    """
-    ❑  Adds snapshots (root / children) and keeps the DAG in-memory
-    ❑  Optionally mirrors headers to a tiny SQLite DB (so you can kill +
-       resume a long search)
-    ❑  Hands out raw snapshot **bytes**; decoding is up to the caller.
-    """
-
-    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
-    # construction                                                            #
-    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
-
-    def __init__(
-        self,
-        snapshot_store: FilesystemSnapshotStore | None = None,
-        *,
-        db_path: Path | str | None = None,
-    ):
-        self.snap_store = snapshot_store or FilesystemSnapshotStore()
-        self.graph: nx.DiGraph = nx.DiGraph()
-        self.db_path = Path(db_path).expanduser() if db_path else None
-        if self.db_path:
-            self._init_sqlite()
-
-    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
-    # public API                                                              #
-    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
-
-    # insertion -------------------------------------------------------------
-
-    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))
-        return snap_id
-
-    def add_child(
-        self,
-        parent_id: str,
-        snapshot_blob: bytes,
-        *,
-        action: Any,
-        reward: float,
-        terminated: bool = False,
-        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:
-            raise KeyError(f"Parent snapshot {parent_id[:8]}… not in tree")
-        depth = self.graph.nodes[parent_id]["meta"].depth + 1  # type: ignore[index]
-        snap_id = self.snap_store.write(snapshot_blob)
-        meta = TrajectorySnapshot(snap_id, parent_id, depth, action, reward, terminated, info)
-        self._add_node(meta)  # records node + (maybe) SQLite
-        self.graph.add_edge(parent_id, snap_id, action=action, reward=reward)  # NX edge attrs
-        return snap_id
-
-    # read-side helpers -----------------------------------------------------
-
-    def get_children(self, snap_id: str) -> tuple[str, ...]:
-        return tuple(self.graph.successors(snap_id))
-
-    def get_parent(self, snap_id: str) -> str | None:
-        preds = tuple(self.graph.predecessors(snap_id))
-        return preds[0] if preds else None
-
-    def is_leaf(self, snap_id: str) -> bool:
-        return self.graph.out_degree(snap_id) == 0
-
-    # simple enumerations useful for MCTS / LATS ---------------------------
-
-    def iter_leaves(self) -> Iterable[str]:
-        """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, ...]:
-        """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, ...]:
-        """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:], strict=False
-        ):
-            actions.append(self.graph.edges[parent, child]["action"])
-        return tuple(reversed(actions))
-
-    # snapshot access -------------------------------------------------------
-
-    def load_snapshot_blob(self, snap_id: str) -> bytes:
-        blob = self.snap_store.read(snap_id)
-        if blob is None:
-            raise FileNotFoundError(f"Snapshot {snap_id[:8]}… missing on disk")
-        return blob
-
-    def load_pickled_payload(self, snap_id: str) -> Any:
-        """Decompress + unpickle whatever you stored under this id."""
-        return pickle.loads(gzip.decompress(self.load_snapshot_blob(snap_id)))
-
-    # mutation --------------------------------------------------------------
-
-    def prune_subtree(self, root_id: str) -> None:
-        """Remove *root_id* and all its descendants from the in-mem graph and DB."""
-        doomed = list(nx.dfs_preorder_nodes(self.graph, root_id))
-        self.graph.remove_nodes_from(doomed)
-        if self.db_path:
-            with sqlite3.connect(self.db_path) as conn:
-                conn.executemany("DELETE FROM nodes WHERE snap_id = ?;", ((n,) for n in doomed))
-                conn.executemany(
-                    "DELETE FROM edges WHERE parent_id = ? OR child_id = ?;",
-                    ((n, n) for n in doomed),
-                )
-                conn.commit()
-
-    def wipe(self) -> None:
-        """Clear the *entire* tree (does **not** delete snapshot files)."""
-        self.graph.clear()
-        if self.db_path:
-            with sqlite3.connect(self.db_path) as conn:
-                conn.executescript("DELETE FROM nodes; DELETE FROM edges;")
-                conn.commit()
-
-    # ------------------------------------------------------------------- #
-    # internal helpers                                                     #
-    # ------------------------------------------------------------------- #
-
-    def _add_node(self, meta: TrajectorySnapshot) -> None:
-        self.graph.add_node(meta.snap_id, meta=meta)
-        if self.db_path:
-            self._sqlite_insert(meta)
-
-    # ------------------------------------------------------------------- #
-    # tiny SQLite backing store (optional)                                 #
-    # ------------------------------------------------------------------- #
-
-    def _init_sqlite(self) -> None:
-        self.db_path.parent.mkdir(parents=True, exist_ok=True)
-        with sqlite3.connect(self.db_path) as conn:
-            conn.executescript(
-                """
-                CREATE TABLE IF NOT EXISTS nodes(
-                    snap_id   TEXT PRIMARY KEY,
-                    parent_id TEXT,
-                    depth     INTEGER,
-                    action    TEXT,
-                    reward    REAL,
-                    terminated INTEGER,
-                    info      TEXT
-                );
-                CREATE TABLE IF NOT EXISTS edges(
-                    parent_id TEXT,
-                    child_id  TEXT,
-                    action    TEXT,
-                    reward    REAL,
-                    PRIMARY KEY(parent_id, child_id)
-                );
-                """
-            )
-            conn.commit()
-
-    def _sqlite_insert(self, meta: TrajectorySnapshot) -> None:
-        with sqlite3.connect(self.db_path) as conn:
-            conn.execute(
-                """INSERT OR IGNORE INTO nodes
-                   (snap_id, parent_id, depth, action, reward, terminated, info)
-                   VALUES (?,?,?,?,?,?,?)""",
-                (
-                    meta.snap_id,
-                    meta.parent_id,
-                    meta.depth,
-                    json.dumps(meta.action),
-                    meta.reward,
-                    int(meta.terminated),
-                    json.dumps(meta.info),
-                ),
-            )
-            if meta.parent_id:
-                conn.execute(
-                    """INSERT OR IGNORE INTO edges
-                       (parent_id, child_id, action, reward)
-                       VALUES (?,?,?,?)""",
-                    (
-                        meta.parent_id,
-                        meta.snap_id,
-                        json.dumps(meta.action),
-                        meta.reward,
-                    ),
-                )
-            conn.commit()