synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/environments/examples/bandit/environment.py

@@ -1,194 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from pydantic import BaseModel, Field, ValidationError
-
-from synth_ai.environments.environment.shared_engine import (
-    GetObservationCallable,
-    InternalObservation,
-)
-from synth_ai.environments.environment.tools import (
-    AbstractTool,
-    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 (
-    BanditEngine,
-    BanditEngineSnapshot,
-    SynthBanditCheckpointObservationCallable,
-    SynthBanditObservationCallable,
-)
-
-
-class BanditActionInput(BaseModel):
-    arm: int = Field(..., ge=0, description="Index of the arm to pull (0-based)")
-
-
-class BanditInteractTool(AbstractTool):
-    name = "pull_arm"
-    description = "Pull a specific bandit arm to receive a stochastic reward."
-    call_schema = BanditActionInput
-    result_schema = ToolResult
-
-    def __init__(self, engine: BanditEngine):
-        self.engine = engine
-
-    async def __call__(self, call: EnvToolCall) -> ToolResult:
-        try:
-            parsed = self.call_schema(**call.args)
-        except ValidationError as exc:
-            return ToolResult(ok=False, error=str(exc))
-
-        try:
-            private_state, public_state = await self.engine._step_engine(parsed.arm)
-        except Exception as exc:  # noqa: BLE001 - propagate as tool error
-            priv, pub = self.engine.get_current_states_for_observation()
-            return ToolResult(
-                ok=False,
-                error=str(exc),
-                payload={"private_state": priv, "public_state": pub},
-            )
-
-        return ToolResult(
-            ok=True,
-            payload={"private_state": private_state, "public_state": public_state},
-        )
-
-
-class BanditEnvironment(StatefulEnvironment, ReproducibleEnvironment[BanditEngine]):
-    def __init__(
-        self,
-        task_instance: TaskInstance,
-        custom_step_obs: GetObservationCallable | None = None,
-        custom_ckpt_obs: GetObservationCallable | None = None,
-    ) -> None:
-        self.name = "Bandit"
-        self.task_instance = task_instance
-        self.custom_step_observation_callable = custom_step_obs or SynthBanditObservationCallable()
-        self.custom_checkpoint_observation_callable = (
-            custom_ckpt_obs or SynthBanditCheckpointObservationCallable()
-        )
-        self.engine = BanditEngine(task_instance)
-        self._interact_tool = BanditInteractTool(self.engine)
-
-    async def initialize(self) -> InternalObservation:
-        priv, pub = await self.engine._reset_engine()
-        return await self._to_observation(priv, pub, self.custom_step_observation_callable)
-
-    async def step(self, tool_calls: list[EnvToolCall] | EnvToolCall | Any) -> InternalObservation:
-        validated_call = self.validate_tool_calls(tool_calls)
-        result = await self._interact_tool(validated_call)
-
-        if result.ok and result.payload:
-            priv = result.payload["private_state"]
-            pub = result.payload["public_state"]
-            return await self._to_observation(priv, pub, self.custom_step_observation_callable)
-
-        priv, pub = self.engine.get_current_states_for_observation()
-        return await self._to_observation(
-            priv,
-            pub,
-            self.custom_step_observation_callable,
-            extra_obs={"error": result.error} if result.error else None,
-        )
-
-    async def checkpoint(self) -> InternalObservation:
-        priv, pub = self.engine.get_current_states_for_observation()
-        return await self._to_observation(priv, pub, self.custom_checkpoint_observation_callable)
-
-    async def terminate(self) -> InternalObservation:
-        priv, pub = self.engine.get_current_states_for_observation()
-        self.engine.terminated = True
-        pub.terminated = True
-        priv.terminated = True
-        if pub.status != "completed":
-            pub.status = "terminated"
-        return await self._to_observation(priv, pub, self.custom_checkpoint_observation_callable)
-
-    def validate_tool_calls(self, tool_calls: Any) -> EnvToolCall:
-        if isinstance(tool_calls, EnvToolCall):
-            candidate = tool_calls
-        elif isinstance(tool_calls, dict):
-            if "tool" in tool_calls:
-                candidate = EnvToolCall(tool=tool_calls["tool"], args=tool_calls.get("args", {}))
-            elif "name" in tool_calls:
-                candidate = EnvToolCall(
-                    tool=tool_calls["name"], args=tool_calls.get("parameters", {})
-                )
-            elif "function" in tool_calls:
-                func_spec = tool_calls["function"]
-                candidate = EnvToolCall(
-                    tool=func_spec.get("name", "pull_arm"),
-                    args=func_spec.get("arguments", {}),
-                )
-            else:
-                candidate = EnvToolCall(tool="pull_arm", args=tool_calls)
-        elif isinstance(tool_calls, list):
-            if not tool_calls:
-                raise ValueError("Empty tool calls list")
-            return self.validate_tool_calls(tool_calls[0])
-        else:
-            if isinstance(tool_calls, int):
-                return EnvToolCall(tool="pull_arm", args={"arm": tool_calls})
-            try:
-                return EnvToolCall(tool="pull_arm", args={"arm": int(tool_calls)})
-            except (TypeError, ValueError) as exc:
-                raise TypeError("Unsupported tool_calls format for bandit environment") from exc
-
-        tool_name = candidate.tool
-        if tool_name not in {"pull_arm", "interact"}:
-            raise ValueError(f"Unknown tool: {tool_name}")
-
-        args = dict(candidate.args or {})
-        if "arm" not in args:
-            for alias in ("action", "index", "arm_index", "armId", "choice"):
-                if alias in args:
-                    args["arm"] = args[alias]
-                    break
-        if "arm" not in args:
-            raise ValueError("Missing required 'arm' argument")
-
-        try:
-            arm_idx = int(args["arm"])
-        except (TypeError, ValueError) as exc:
-            raise ValueError("'arm' argument must be an integer") from exc
-
-        if arm_idx < 0:
-            raise ValueError("'arm' argument must be non-negative")
-
-        return EnvToolCall(tool="pull_arm", args={"arm": arm_idx})
-
-    async def _to_observation(
-        self,
-        priv,
-        pub,
-        obs_cb: GetObservationCallable | None,
-        extra_obs: dict[str, Any] | None = None,
-    ) -> InternalObservation:
-        observation: InternalObservation
-        if obs_cb:
-            observation = await obs_cb.get_observation(pub, priv)
-        else:
-            observation = {}
-        if extra_obs and isinstance(observation, dict):
-            observation.update(extra_obs)
-        return observation
-
-    async def _serialize_engine(self) -> BanditEngineSnapshot:
-        return await self.engine._serialize_engine()
-
-    @classmethod
-    async def _deserialize_engine(
-        cls,
-        snapshot: BanditEngineSnapshot,
-        task_instance: TaskInstance,
-    ) -> BanditEnvironment:
-        env = cls(task_instance)
-        env.engine = await BanditEngine._deserialize_engine(snapshot)
-        env._interact_tool = BanditInteractTool(env.engine)
-        return env

synth_ai/environments/examples/bandit/taskset.py

@@ -1,200 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable
-from dataclasses import dataclass
-from typing import Any
-from uuid import UUID, uuid4
-
-from synth_ai.environments.tasks.core import (
-    Impetus,
-    Intent,
-    SplitInfo,
-    TaskInstance,
-    TaskInstanceMetadata,
-    TaskInstanceSet,
-)
-
-
-@dataclass
-class BanditTaskInstanceMetadata(TaskInstanceMetadata):
-    name: str
-    bandit_type: str
-    arm_probabilities: list[float] | None
-    arm_means: list[float] | None
-    arm_stds: list[float] | None
-    max_steps: int
-    seed: int | None = None
-
-
-@dataclass
-class BanditTaskInstance(TaskInstance):
-    async def serialize(self) -> dict[str, Any]:
-        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": {
-                "name": self.metadata.name,
-                "bandit_type": self.metadata.bandit_type,
-                "arm_probabilities": self.metadata.arm_probabilities,
-                "arm_means": self.metadata.arm_means,
-                "arm_stds": self.metadata.arm_stds,
-                "max_steps": self.metadata.max_steps,
-                "seed": self.metadata.seed,
-            },
-            "is_reproducible": self.is_reproducible,
-            "initial_engine_snapshot": self.initial_engine_snapshot,
-        }
-
-    @classmethod
-    async def deserialize(cls, data: dict[str, Any]) -> BanditTaskInstance:
-        metadata = BanditTaskInstanceMetadata(
-            name=data["metadata"].get("name", "bandit"),
-            bandit_type=data["metadata"].get("bandit_type", "bernoulli"),
-            arm_probabilities=data["metadata"].get("arm_probabilities"),
-            arm_means=data["metadata"].get("arm_means"),
-            arm_stds=data["metadata"].get("arm_stds"),
-            max_steps=int(data["metadata"].get("max_steps", 100)),
-            seed=data["metadata"].get("seed"),
-        )
-        return cls(
-            id=UUID(data["id"]),
-            impetus=Impetus(instructions=data["impetus"]["instructions"]),
-            intent=Intent(
-                rubric=data["intent"].get("rubric", {}),
-                gold_trajectories=data["intent"].get("gold_trajectories"),
-                gold_state_diff=data["intent"].get("gold_state_diff", {}),
-            ),
-            metadata=metadata,
-            is_reproducible=bool(data.get("is_reproducible", True)),
-            initial_engine_snapshot=data.get("initial_engine_snapshot"),
-        )
-
-
-def _expected_rewards(metadata: BanditTaskInstanceMetadata) -> list[float]:
-    if metadata.bandit_type.lower() == "bernoulli" and metadata.arm_probabilities:
-        return [float(p) for p in metadata.arm_probabilities]
-    if metadata.bandit_type.lower() == "gaussian" and metadata.arm_means:
-        return [float(m) for m in metadata.arm_means]
-    return []
-
-
-def _default_bandit_configs() -> list[dict[str, Any]]:
-    return [
-        {
-            "name": "bernoulli-easy",
-            "bandit_type": "bernoulli",
-            "arm_probabilities": [0.1, 0.4, 0.8],
-            "max_steps": 50,
-            "seed": 7,
-        },
-        {
-            "name": "bernoulli-close",
-            "bandit_type": "bernoulli",
-            "arm_probabilities": [0.45, 0.5, 0.55],
-            "max_steps": 75,
-            "seed": 21,
-        },
-        {
-            "name": "gaussian-wide",
-            "bandit_type": "gaussian",
-            "arm_means": [0.0, 0.3, 1.0],
-            "arm_stds": [0.2, 0.2, 0.4],
-            "max_steps": 60,
-            "seed": 14,
-        },
-    ]
-
-
-def _build_impetus(metadata: BanditTaskInstanceMetadata, arm_count: int) -> Impetus:
-    bandit_desc = metadata.bandit_type.capitalize()
-    return Impetus(
-        instructions=(
-            f"You are interacting with a {bandit_desc} multi-armed bandit task. "
-            f"There are {arm_count} arms, indexed from 0 to {arm_count - 1}. "
-            f"You may pull up to {metadata.max_steps} arms. "
-            "Your objective is to maximize the cumulative reward by learning which arm has the highest expected payoff."
-        )
-    )
-
-
-def _build_intent(expected_rewards: Iterable[float]) -> Intent:
-    rewards = list(expected_rewards)
-    best_arm = max(range(len(rewards)), key=rewards.__getitem__) if rewards else 0
-    return Intent(
-        rubric={
-            "goal": "Maximize cumulative reward over the episode",
-            "measurement": "Higher total reward indicates better performance",
-        },
-        gold_trajectories=None,
-        gold_state_diff={
-            "best_arm_index": best_arm,
-            "expected_rewards": rewards,
-        },
-    )
-
-
-async def create_bandit_taskset(
-    configs: list[dict[str, Any]] | None = None,
-) -> TaskInstanceSet:
-    configs = configs or _default_bandit_configs()
-
-    instances: list[BanditTaskInstance] = []
-    for config in configs:
-        metadata = BanditTaskInstanceMetadata(
-            name=config.get("name", "bandit"),
-            bandit_type=config.get("bandit_type", "bernoulli"),
-            arm_probabilities=config.get("arm_probabilities"),
-            arm_means=config.get("arm_means"),
-            arm_stds=config.get("arm_stds"),
-            max_steps=int(config.get("max_steps", 100)),
-            seed=config.get("seed"),
-        )
-
-        expected = _expected_rewards(metadata)
-        arm_count = len(expected) if expected else (
-            len(metadata.arm_probabilities or [])
-            or len(metadata.arm_means or [])
-            or 0
-        )
-        if arm_count == 0:
-            arm_count = 1
-
-        impetus = _build_impetus(metadata, arm_count)
-        intent = _build_intent(expected)
-
-        instance = BanditTaskInstance(
-            id=uuid4(),
-            impetus=impetus,
-            intent=intent,
-            metadata=metadata,
-            is_reproducible=True,
-            initial_engine_snapshot=None,
-        )
-        instances.append(instance)
-
-    # Simple deterministic splits by index
-    val_ids = {instances[i].id for i in range(0, len(instances), 3)}
-    test_ids = {instances[i].id for i in range(1, len(instances), 3)}
-
-    split_info = SplitInfo(
-        val_instance_ids=val_ids,
-        test_instance_ids=test_ids,
-        _is_split_defined=bool(instances),
-    )
-
-    return TaskInstanceSet(
-        name="Bandit Example TaskSet",
-        description="Lightweight Bernoulli and Gaussian bandit tasks inspired by OpenAI Gym bandits.",
-        instances=instances,
-        split_info=split_info,
-    )
-
-
-# Alias for convenience
-
-taskset = create_bandit_taskset

synth_ai/environments/examples/crafter_classic/__init__.py

@@ -1,8 +0,0 @@
-from .config_logging import configure_logging
-from .engine import CrafterEngine
-from .environment import CrafterClassicEnvironment
-
-# Configure logging when crafter_classic module is imported
-configure_logging()
-
-__all__ = ["CrafterClassicEnvironment", "CrafterEngine"]

synth_ai/environments/examples/crafter_classic/agent_demos/analyze_semantic_words_markdown.py

@@ -1,250 +0,0 @@
-#!/usr/bin/env python3
-"""
-Run Crafter agent and analyze semantic map words - output as markdown tables only.
-
-This script:
-1. Runs a Crafter agent for multiple episodes
-2. Extracts all unique words from the semantic map observations
-3. Outputs analysis as markdown tables (no plotting dependencies)
-
-Usage:
-    python analyze_semantic_words_markdown.py --model gemini-1.5-flash --episodes 3
-"""
-
-import argparse
-import asyncio
-import json
-import re
-
-# Import the Crafter agent
-import sys
-from collections import Counter
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Set
-
-sys.path.append(str(Path(__file__).parent))
-from test_crafter_react_agent import run_crafter_episodes
-
-
-def extract_words_from_semantic_map(observation: str) -> set[str]:
-    """Extract meaningful words from a semantic map observation string."""
-    if not observation or "semantic_map" not in observation.lower():
-        return set()
-    
-    # Look for patterns like object names in the semantic map
-    # Common Crafter objects/entities
-    crafter_words = {
-        # Resources
-        'wood', 'stone', 'coal', 'iron', 'diamond', 'water',
-        # Animals  
-        'cow', 'pig', 'skeleton', 'zombie',
-        # Structures/Objects
-        'tree', 'grass', 'furnace', 'table', 'bed', 'chest',
-        'house', 'fence', 'door', 'wall',
-        # Tools
-        'axe', 'pickaxe', 'sword', 'shovel',
-        # Food
-        'bread', 'meat', 'apple',
-        # Environment
-        'mountain', 'river', 'forest', 'desert', 'cave',
-        'lava', 'sand', 'dirt', 'path',
-        # Actions/States
-        'crafting', 'mining', 'building', 'farming',
-        'health', 'hunger', 'energy'
-    }
-    
-    # Extract words using regex - look for alphabetic words
-    words = re.findall(r'\b[a-zA-Z]{3,}\b', observation.lower())
-    
-    # Filter to keep only meaningful Crafter-related words
-    found_words = set()
-    for word in words:
-        if word in crafter_words or any(cw in word for cw in crafter_words):
-            found_words.add(word)
-    return found_words
-
-def analyze_episode_traces(traces_data: list[dict]) -> dict[str, int]:
-    """Analyze traces to extract semantic map words."""
-    word_counter = Counter()
-    
-    for episode_data in traces_data:
-        if 'observations' in episode_data:
-            for obs in episode_data['observations']:
-                if isinstance(obs, dict):
-                    # Look for semantic map in observation
-                    obs_str = str(obs)
-                    words = extract_words_from_semantic_map(obs_str)
-                    word_counter.update(words)
-                elif isinstance(obs, str):
-                    words = extract_words_from_semantic_map(obs)
-                    word_counter.update(words)
-    
-    return dict(word_counter)
-
-def generate_markdown_report(word_counts: dict[str, int], model: str, episodes: int) -> str:
-    """Generate a markdown report of the semantic map analysis."""
-    if not word_counts:
-        return "# Semantic Map Analysis\n\n**No words found in semantic maps!**\n"
-    
-    total_words = sum(word_counts.values())
-    unique_words = len(word_counts)
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    
-    # Sort words by frequency
-    sorted_words = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)
-    
-    # Generate markdown
-    md = f"""# Semantic Map Word Analysis
-    
-**Model:** {model}  
-**Episodes:** {episodes}  
-**Generated:** {timestamp}  
-
-## Summary
-
-- **Total word occurrences:** {total_words}
-- **Unique words discovered:** {unique_words}
-- **Average occurrences per word:** {total_words/unique_words:.1f}
-
-## Top Words by Frequency
-
-| Rank | Word | Count | Percentage |
-|------|------|-------|------------|
-"""
-    
-    # Top 15 words table
-    for i, (word, count) in enumerate(sorted_words[:15], 1):
-        percentage = (count / total_words) * 100
-        md += f"| {i:2d} | {word} | {count} | {percentage:.1f}% |\n"
-    
-    # Word categories
-    categories = {
-        "Resources": ['wood', 'stone', 'coal', 'iron', 'diamond', 'water'],
-        "Animals": ['cow', 'pig', 'skeleton', 'zombie'],
-        "Structures": ['tree', 'furnace', 'table', 'house', 'chest', 'fence', 'door'],
-        "Tools": ['axe', 'pickaxe', 'sword', 'shovel'],
-        "Environment": ['mountain', 'river', 'forest', 'desert', 'cave', 'lava', 'grass'],
-        "Food": ['bread', 'meat', 'apple']
-    }
-    
-    md += "\n## Words by Category\n\n"
-    
-    for category, words in categories.items():
-        found_words = [(w, word_counts[w]) for w in words if w in word_counts]
-        if found_words:
-            md += f"### {category}\n\n"
-            md += "| Word | Count |\n|------|-------|\n"
-            for word, count in sorted(found_words, key=lambda x: x[1], reverse=True):
-                md += f"| {word} | {count} |\n"
-            md += "\n"
-    
-    # Frequency distribution
-    freq_counts = Counter(word_counts.values())
-    md += "## Frequency Distribution\n\n"
-    md += "| Frequency | Number of Words |\n|-----------|----------------|\n"
-    for freq in sorted(freq_counts.keys(), reverse=True):
-        md += f"| {freq} | {freq_counts[freq]} |\n"
-    
-    # All words alphabetically
-    md += "\n## All Words (Alphabetical)\n\n"
-    md += "| Word | Count |\n|------|-------|\n"
-    for word in sorted(word_counts.keys()):
-        md += f"| {word} | {word_counts[word]} |\n"
-    
-    return md
-
-async def main():
-    parser = argparse.ArgumentParser(description="Analyze semantic map words - markdown output only")
-    parser.add_argument("--model", default="gemini-1.5-flash", 
-                       help="Model to use for agent (default: gemini-1.5-flash)")
-    parser.add_argument("--episodes", type=int, default=3,
-                       help="Number of episodes to run (default: 3)")
-    parser.add_argument("--max-turns", type=int, default=50,
-                       help="Maximum turns per episode (default: 50)")
-    parser.add_argument("--output-dir", default="semantic_analysis",
-                       help="Directory to save analysis results")
-    
-    args = parser.parse_args()
-    
-    print(f"🚀 Running {args.episodes} episodes with {args.model}")
-    print("📊 Will analyze semantic map words and generate markdown report")
-    
-    # Create output directory
-    output_dir = Path(args.output_dir)
-    output_dir.mkdir(exist_ok=True)
-    
-    # Run the agent episodes
-    try:
-        print("\n🎮 Starting Crafter episodes...")
-        traces_result = await run_crafter_episodes(
-            model_name=args.model,
-            num_episodes=args.episodes,
-            max_turns=args.max_turns,
-            difficulty="easy",
-            base_seed=1000
-        )
-        
-        print(f"✅ Completed {args.episodes} episodes")
-        
-        # Analyze semantic map words
-        print("\n🔍 Analyzing semantic map words...")
-        word_counts = analyze_episode_traces(traces_result)
-        
-        # Generate markdown report
-        print("\n📝 Generating markdown report...")
-        markdown_report = generate_markdown_report(word_counts, args.model, args.episodes)
-        
-        # Save markdown report
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        report_file = output_dir / f"semantic_analysis_{args.model}_{timestamp}.md"
-        
-        with open(report_file, 'w') as f:
-            f.write(markdown_report)
-        
-        print(f"💾 Markdown report saved to: {report_file}")
-        
-        # Also save raw data as JSON
-        analysis_data = {
-            "model": args.model,
-            "episodes": args.episodes,
-            "timestamp": timestamp,
-            "word_counts": word_counts,
-            "total_unique_words": len(word_counts),
-            "total_word_occurrences": sum(word_counts.values())
-        }
-        
-        json_file = output_dir / f"word_data_{args.model}_{timestamp}.json"
-        with open(json_file, 'w') as f:
-            json.dump(analysis_data, f, indent=2)
-        
-        print(f"💾 Raw data saved to: {json_file}")
-        
-        # Print summary to console
-        print("\n" + "="*60)
-        print("SEMANTIC MAP WORD ANALYSIS SUMMARY")
-        print("="*60)
-        
-        if word_counts:
-            total_words = sum(word_counts.values())
-            unique_words = len(word_counts)
-            print(f"Total word occurrences: {total_words}")
-            print(f"Unique words discovered: {unique_words}")
-            
-            # Top 10 most common words
-            sorted_words = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)
-            print("\nTop 10 most frequent words:")
-            for i, (word, count) in enumerate(sorted_words[:10], 1):
-                print(f"{i:2d}. {word:<12} ({count} times)")
-        else:
-            print("No semantic map words found!")
-        
-        print(f"\n📄 Full analysis available in: {report_file}")
-        print("\n🎉 Analysis complete!")
-        
-    except Exception as e:
-        print(f"❌ Error during analysis: {e}")
-        raise
-
-if __name__ == "__main__":
-    asyncio.run(main())