synth-ai 0.2.4.dev6__py3-none-any.whl → 0.2.4.dev8__py3-none-any.whl

synth_ai/environments/examples/wordle/engine.py

@@ -1,21 +1,20 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
-from collections import Counter
 import random
 import string
+from collections import Counter
+from dataclasses import dataclass
+from typing import Any
 
-from synth_ai.environments.stateful.engine import StatefulEngine, StatefulEngineSnapshot
-from synth_ai.environments.reproducibility.core import IReproducibleEngine
-from synth_ai.environments.environment.rewards.core import RewardStack, RewardComponent
+from synth_ai.environments.environment.rewards.core import RewardComponent, RewardStack
 from synth_ai.environments.environment.shared_engine import (
     GetObservationCallable,
     InternalObservation,
 )
+from synth_ai.environments.reproducibility.core import IReproducibleEngine
+from synth_ai.environments.stateful.engine import StatefulEngine, StatefulEngineSnapshot
 from synth_ai.environments.tasks.core import TaskInstance
 
-
 DEFAULT_SOLUTIONS = [
     "cigar",
     "rebut",
@@ -98,10 +97,10 @@ class WordlePublicState:
     word_length: int
     remaining_guesses: int
     max_guesses: int
-    guesses: List[str]
-    feedback: List[str]  # Parallel to guesses; strings of 'G/Y/B'
-    last_feedback: Optional[str]
-    last_guess: Optional[str]
+    guesses: list[str]
+    feedback: list[str]  # Parallel to guesses; strings of 'G/Y/B'
+    last_feedback: str | None
+    last_guess: str | None
     terminated: bool
     status: str  # "in_progress" | "won" | "lost"
 
@@ -110,7 +109,7 @@ class WordlePublicState:
         if not self.guesses:
             return "(no guesses yet)"
         lines = []
-        for g, fb in zip(self.guesses, self.feedback):
+        for g, fb in zip(self.guesses, self.feedback, strict=False):
             spaced = " ".join(list(fb))
             lines.append(f"{g.upper()} | {spaced}")
         return "\n".join(lines)
@@ -126,8 +125,8 @@ class WordlePrivateState:
 
 @dataclass
 class WordleEngineSnapshot(StatefulEngineSnapshot):
-    task_instance_dict: Dict
-    engine_snapshot: Dict
+    task_instance_dict: dict
+    engine_snapshot: dict
 
 
 class WordleWinComponent(RewardComponent):
@@ -156,20 +155,26 @@ class WordleEngine(StatefulEngine, IReproducibleEngine):
         self.max_guesses: int = getattr(md, "max_guesses", 6) if md else 6
         self.enforce_wordlist: bool = getattr(md, "enforce_wordlist", False) if md else False
         # Toggle: whether invalid actions consume a turn (default True)
-        self.consume_invalid_attempts: bool = getattr(md, "consume_invalid_attempts", True) if md else True
+        self.consume_invalid_attempts: bool = (
+            getattr(md, "consume_invalid_attempts", True) if md else True
+        )
 
-        self.base_word_list: List[str] = [
+        self.base_word_list: list[str] = [
             w for w in DEFAULT_SOLUTIONS if len(w) == self.word_length
         ] or [w for w in DEFAULT_SOLUTIONS if len(w) == 5]
 
         # Target selection: prefer explicit target_word in metadata; else pick deterministically by seed
-        self.fixed_target: Optional[str] = _sanitize(getattr(md, "target_word", "")) if md and getattr(md, "target_word", None) else None
-        self.seed: Optional[int] = getattr(md, "seed", None) if md else None
+        self.fixed_target: str | None = (
+            _sanitize(getattr(md, "target_word", ""))
+            if md and getattr(md, "target_word", None)
+            else None
+        )
+        self.seed: int | None = getattr(md, "seed", None) if md else None
 
         # Runtime state
-        self.target: Optional[str] = None
-        self.guesses: List[str] = []
-        self.feedback: List[str] = []
+        self.target: str | None = None
+        self.guesses: list[str] = []
+        self.feedback: list[str] = []
         self.remaining_guesses: int = self.max_guesses
         self.status: str = "in_progress"
         self.terminated: bool = False
@@ -179,7 +184,9 @@ class WordleEngine(StatefulEngine, IReproducibleEngine):
         self.invalid_component = WordleInvalidGuessComponent()
         self.reward_stack = RewardStack([WordleWinComponent(), self.invalid_component])
 
-    async def _reset_engine(self, *, seed: int | None = None) -> Tuple[WordlePrivateState, WordlePublicState]:
+    async def _reset_engine(
+        self, *, seed: int | None = None
+    ) -> tuple[WordlePrivateState, WordlePublicState]:
         if seed is None:
             seed = self.seed
         if seed is not None and self.fixed_target is None:
@@ -211,7 +218,7 @@ class WordleEngine(StatefulEngine, IReproducibleEngine):
         )
         return priv, pub
 
-    async def _step_engine(self, action: str) -> Tuple[WordlePrivateState, WordlePublicState]:
+    async def _step_engine(self, action: str) -> tuple[WordlePrivateState, WordlePublicState]:
         assert self.target is not None
         guess = _sanitize(action)
 
@@ -307,7 +314,7 @@ class WordleEngine(StatefulEngine, IReproducibleEngine):
         )
 
     @classmethod
-    async def _deserialize_engine(cls, snapshot: WordleEngineSnapshot) -> "WordleEngine":
+    async def _deserialize_engine(cls, snapshot: WordleEngineSnapshot) -> WordleEngine:
         task_instance = await TaskInstance.deserialize(snapshot.task_instance_dict)
         engine = cls(task_instance)
         s = snapshot.engine_snapshot
@@ -327,7 +334,7 @@ class WordleEngine(StatefulEngine, IReproducibleEngine):
         engine.total_reward = s.get("total_reward", 0.0)
         return engine
 
-    def get_current_states_for_observation(self) -> Tuple[WordlePrivateState, WordlePublicState]:
+    def get_current_states_for_observation(self) -> tuple[WordlePrivateState, WordlePublicState]:
         pub = WordlePublicState(
             word_length=self.word_length,
             remaining_guesses=self.remaining_guesses,

synth_ai/environments/examples/wordle/environment.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-from typing import Optional, Dict, Any, Union
+from typing import Any
+
 from pydantic import BaseModel, Field
 
-from synth_ai.environments.stateful.core import StatefulEnvironment
-from synth_ai.environments.reproducibility.core import ReproducibleEnvironment
 from synth_ai.environments.environment.shared_engine import (
     GetObservationCallable,
     InternalObservation,
@@ -14,15 +13,17 @@ from synth_ai.environments.environment.tools import (
     EnvToolCall,
     ToolResult,
 )
+from synth_ai.environments.reproducibility.core import ReproducibleEnvironment
+from synth_ai.environments.stateful.core import StatefulEnvironment
 from synth_ai.environments.tasks.core import TaskInstance
 
 from .engine import (
+    SynthWordleCheckpointObservationCallable,
+    SynthWordleObservationCallable,
     WordleEngine,
-    WordlePublicState,
-    WordlePrivateState,
     WordleEngineSnapshot,
-    SynthWordleObservationCallable,
-    SynthWordleCheckpointObservationCallable,
+    WordlePrivateState,
+    WordlePublicState,
 )
 
 
@@ -47,15 +48,17 @@ class WordleInteractTool(AbstractTool):
         except Exception as e:
             # Return current state with error message
             priv, pub = self.engine.get_current_states_for_observation()
-            return ToolResult(ok=False, error=str(e), payload={"public_state": pub, "private_state": priv})
+            return ToolResult(
+                ok=False, error=str(e), payload={"public_state": pub, "private_state": priv}
+            )
 
 
 class WordleEnvironment(StatefulEnvironment, ReproducibleEnvironment[WordleEngine]):
     def __init__(
         self,
         task_instance: TaskInstance,
-        custom_step_obs: Optional[GetObservationCallable] = None,
-        custom_ckpt_obs: Optional[GetObservationCallable] = None,
+        custom_step_obs: GetObservationCallable | None = None,
+        custom_ckpt_obs: GetObservationCallable | None = None,
     ) -> None:
         self.name = "Wordle"
         self.task_instance = task_instance
@@ -101,10 +104,13 @@ class WordleEnvironment(StatefulEnvironment, ReproducibleEnvironment[WordleEngin
             if "tool" in tool_calls:
                 validated = EnvToolCall(tool=tool_calls["tool"], args=tool_calls.get("args", {}))
             elif "name" in tool_calls:
-                validated = EnvToolCall(tool=tool_calls["name"], args=tool_calls.get("parameters", {}))
+                validated = EnvToolCall(
+                    tool=tool_calls["name"], args=tool_calls.get("parameters", {})
+                )
             elif "function" in tool_calls:
                 validated = EnvToolCall(
-                    tool=tool_calls["function"]["name"], args=tool_calls["function"].get("arguments", {})
+                    tool=tool_calls["function"]["name"],
+                    args=tool_calls["function"].get("arguments", {}),
                 )
             else:
                 # Treat remaining keys as args; default tool name
@@ -129,8 +135,8 @@ class WordleEnvironment(StatefulEnvironment, ReproducibleEnvironment[WordleEngin
         self,
         priv: WordlePrivateState,
         pub: WordlePublicState,
-        obs_cb: Optional[GetObservationCallable],
-        extra_obs: Optional[Dict[str, Any]] = None,
+        obs_cb: GetObservationCallable | None,
+        extra_obs: dict[str, Any] | None = None,
     ) -> InternalObservation:
         if obs_cb:
             obs = await obs_cb.get_observation(pub, priv)
@@ -146,9 +152,8 @@ class WordleEnvironment(StatefulEnvironment, ReproducibleEnvironment[WordleEngin
     @classmethod
     async def _deserialize_engine(
         cls, snapshot: WordleEngineSnapshot, task_instance: TaskInstance
-    ) -> "WordleEnvironment":
+    ) -> WordleEnvironment:
         env = cls(task_instance)
         env.engine = await WordleEngine._deserialize_engine(snapshot)
         env._interact_tool = WordleInteractTool(env.engine)
         return env
-

synth_ai/environments/examples/wordle/helpers/generate_instances_wordfreq.py

@@ -10,24 +10,24 @@ Usage:
 This script writes a deterministic list of 5-letter English words ranked by frequency.
 Commit the resulting instances.json to remove runtime dependencies.
 """
+
 from __future__ import annotations
 
 import argparse
 import json
 import re
-from typing import List
 
-from wordfreq import zipf_frequency, top_n_list
+from wordfreq import top_n_list, zipf_frequency
 
 
-def build_word_list(count: int, length: int, min_zipf: float, wordlist: str = "large") -> List[str]:
-    N = max(count * 20, 5000)
-    cands = [w.lower() for w in top_n_list("en", N, wordlist=wordlist)]
+def build_word_list(count: int, length: int, min_zipf: float, wordlist: str = "large") -> list[str]:
+    n_candidates = max(count * 20, 5000)
+    cands = [w.lower() for w in top_n_list("en", n_candidates, wordlist=wordlist)]
     cands = [w for w in cands if len(w) == length and re.fullmatch(r"[a-z]+", w)]
     scored = [(w, zipf_frequency(w, "en")) for w in cands]
     scored = [p for p in scored if p[1] >= float(min_zipf)]
     scored.sort(key=lambda t: (-t[1], t[0]))
-    out: List[str] = []
+    out: list[str] = []
     seen = set()
     for w, _ in scored:
         if w in seen:

synth_ai/environments/examples/wordle/taskset.py

@@ -1,19 +1,17 @@
 from __future__ import annotations
 
 import json
-import random
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Tuple
-from uuid import uuid4, UUID
+from uuid import UUID
 
 from synth_ai.environments.tasks.core import (
-    TaskInstance,
-    TaskInstanceMetadata,
-    TaskInstanceSet,
     Impetus,
     Intent,
     SplitInfo,
+    TaskInstance,
+    TaskInstanceMetadata,
+    TaskInstanceSet,
 )
 
 from .engine import DEFAULT_SOLUTIONS
@@ -53,7 +51,7 @@ class WordleTaskInstance(TaskInstance):
         }
 
     @classmethod
-    async def deserialize(cls, data: dict) -> "WordleTaskInstance":
+    async def deserialize(cls, data: dict) -> WordleTaskInstance:
         from uuid import UUID
 
         metadata = WordleTaskInstanceMetadata(
@@ -81,16 +79,18 @@ class WordleTaskInstance(TaskInstance):
 
 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]:
+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")
@@ -126,11 +126,17 @@ async def create_wordle_taskset(
 
     json_insts, json_defaults = _load_fixed_instances_json()
 
-    instances: List[WordleTaskInstance] = []
+    instances: list[WordleTaskInstance] = []
     # Assemble fixed targets from JSON only (no runtime generation)
-    fixed_targets: List[str] = []
+    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")])
+        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
@@ -167,7 +173,9 @@ async def create_wordle_taskset(
             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]
+        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

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(
@@ -41,6 +41,7 @@ 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