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

synth_ai/environments/examples/crafter_classic/trace_hooks_v3.py

@@ -0,0 +1,229 @@
+"""
+Trace hooks for Crafter Classic environment - v3 version.
+Updated to use the v3 tracing architecture with async support.
+"""
+
+from typing import Any, Optional, Dict, Set
+from datetime import datetime
+
+from synth_ai.tracing_v3.hooks import HookManager
+from synth_ai.tracing_v3.abstractions import BaseEvent, EnvironmentEvent
+
+
+# Achievement categorization by difficulty
+EASY_ACHIEVEMENTS = {
+    "collect_wood",
+    "collect_stone",
+    "collect_sapling",
+    "collect_drink",
+    "place_stone",
+    "place_table",
+    "wake_up",
+    "eat_plant",
+}
+
+MEDIUM_ACHIEVEMENTS = {
+    "make_wood_pickaxe",
+    "make_wood_sword",
+    "place_furnace",
+    "place_plant",
+    "collect_coal",
+    "collect_iron",
+    "eat_cow",
+}
+
+HARD_ACHIEVEMENTS = {
+    "make_stone_pickaxe",
+    "make_stone_sword",
+    "make_iron_pickaxe",
+    "make_iron_sword",
+    "collect_diamond",
+    "defeat_skeleton",
+    "defeat_zombie",
+}
+
+
+async def check_easy_achievements(event_obj: BaseEvent, **kwargs) -> Optional[Dict[str, Any]]:
+    """Hook that fires when an easy achievement is unlocked."""
+    # Only process EnvironmentEvents
+    if not isinstance(event_obj, EnvironmentEvent):
+        return None
+
+    # Get achievements before and after
+    before_achievements = {}
+    after_achievements = {}
+
+    state_before = event_obj.system_state_before
+    state_after = event_obj.system_state_after
+
+    if isinstance(state_before, dict):
+        before_achievements = state_before.get("public_state", {}).get("achievements_status", {})
+    if isinstance(state_after, dict):
+        after_achievements = state_after.get("public_state", {}).get("achievements_status", {})
+
+    # Find new easy achievements
+    new_easy_achievements = []
+    for achievement, status in after_achievements.items():
+        if status and not before_achievements.get(achievement, False):
+            if achievement in EASY_ACHIEVEMENTS:
+                new_easy_achievements.append(achievement)
+
+    if new_easy_achievements:
+        # print(f"🎯 Easy achievement(s) unlocked: {', '.join(new_easy_achievements)}")  # Disabled for clean output
+        return {
+            "achievements": new_easy_achievements,
+            "difficulty": "easy",
+            "timestamp": datetime.now().isoformat(),
+        }
+    return None
+
+
+async def check_medium_achievements(event_obj: BaseEvent, **kwargs) -> Optional[Dict[str, Any]]:
+    """Hook that fires when a medium achievement is unlocked."""
+    # Only process EnvironmentEvents
+    if not isinstance(event_obj, EnvironmentEvent):
+        return None
+
+    # Get achievements before and after
+    before_achievements = {}
+    after_achievements = {}
+
+    state_before = event_obj.system_state_before
+    state_after = event_obj.system_state_after
+
+    if isinstance(state_before, dict):
+        before_achievements = state_before.get("public_state", {}).get("achievements_status", {})
+    if isinstance(state_after, dict):
+        after_achievements = state_after.get("public_state", {}).get("achievements_status", {})
+
+    # Find new medium achievements
+    new_medium_achievements = []
+    for achievement, status in after_achievements.items():
+        if status and not before_achievements.get(achievement, False):
+            if achievement in MEDIUM_ACHIEVEMENTS:
+                new_medium_achievements.append(achievement)
+
+    if new_medium_achievements:
+        # print(f"⭐ Medium achievement(s) unlocked: {', '.join(new_medium_achievements)}")  # Disabled for clean output
+        return {
+            "achievements": new_medium_achievements,
+            "difficulty": "medium",
+            "timestamp": datetime.now().isoformat(),
+        }
+    return None
+
+
+async def check_hard_achievements(event_obj: BaseEvent, **kwargs) -> Optional[Dict[str, Any]]:
+    """Hook that fires when a hard achievement is unlocked."""
+    # Only process EnvironmentEvents
+    if not isinstance(event_obj, EnvironmentEvent):
+        return None
+
+    # Get achievements before and after
+    before_achievements = {}
+    after_achievements = {}
+
+    state_before = event_obj.system_state_before
+    state_after = event_obj.system_state_after
+
+    if isinstance(state_before, dict):
+        before_achievements = state_before.get("public_state", {}).get("achievements_status", {})
+    if isinstance(state_after, dict):
+        after_achievements = state_after.get("public_state", {}).get("achievements_status", {})
+
+    # Find new hard achievements
+    new_hard_achievements = []
+    for achievement, status in after_achievements.items():
+        if status and not before_achievements.get(achievement, False):
+            if achievement in HARD_ACHIEVEMENTS:
+                new_hard_achievements.append(achievement)
+
+    if new_hard_achievements:
+        # print(f"🏆 Hard achievement(s) unlocked: {', '.join(new_hard_achievements)}")  # Disabled for clean output
+        return {
+            "achievements": new_hard_achievements,
+            "difficulty": "hard",
+            "timestamp": datetime.now().isoformat(),
+        }
+    return None
+
+
+async def log_invalid_actions(event_obj: BaseEvent, **kwargs) -> Optional[Dict[str, Any]]:
+    """Hook that logs invalid actions."""
+    from synth_ai.tracing_v3.abstractions import RuntimeEvent
+
+    # Only process RuntimeEvents
+    if not isinstance(event_obj, RuntimeEvent):
+        return None
+
+    # Check if action was invalid
+    if event_obj.metadata.get("valid") is False:
+        action_name = event_obj.metadata.get("action_name", "unknown")
+        # print(f"⚠️  Invalid action attempted: {action_name}")  # Disabled for clean output
+        return {
+            "action": action_name,
+            "valid": False,
+            "timestamp": datetime.now().isoformat(),
+        }
+    return None
+
+
+async def track_reward_milestones(event_obj: BaseEvent, **kwargs) -> Optional[Dict[str, Any]]:
+    """Hook that tracks significant reward events."""
+    # Only process EnvironmentEvents
+    if not isinstance(event_obj, EnvironmentEvent):
+        return None
+
+    reward = event_obj.reward
+    if reward and reward >= 1.0:  # Significant positive reward
+        # print(f"💰 High reward received: {reward}")  # Disabled for clean output
+        return {
+            "reward": reward,
+            "timestamp": datetime.now().isoformat(),
+        }
+    return None
+
+
+# Create the global CRAFTER_HOOKS instance
+CRAFTER_HOOKS = HookManager()
+
+# Register all hooks
+CRAFTER_HOOKS.register(
+    "event_recorded",
+    check_easy_achievements,
+    name="easy_achievements",
+    priority=10,
+    event_types=["environment"],
+)
+
+CRAFTER_HOOKS.register(
+    "event_recorded",
+    check_medium_achievements,
+    name="medium_achievements",
+    priority=10,
+    event_types=["environment"],
+)
+
+CRAFTER_HOOKS.register(
+    "event_recorded",
+    check_hard_achievements,
+    name="hard_achievements",
+    priority=10,
+    event_types=["environment"],
+)
+
+CRAFTER_HOOKS.register(
+    "event_recorded",
+    log_invalid_actions,
+    name="invalid_actions",
+    priority=5,
+    event_types=["runtime"],
+)
+
+CRAFTER_HOOKS.register(
+    "event_recorded",
+    track_reward_milestones,
+    name="reward_milestones",
+    priority=5,
+    event_types=["environment"],
+)

synth_ai/environments/examples/crafter_classic/world_config_patch_simple.py

@@ -0,0 +1,298 @@
+"""
+Simplified monkey patch for configurable world generation in crafter.
+This version modifies generation parameters rather than rewriting functions.
+"""
+
+import json
+import os
+from typing import Dict, Any, Optional
+import crafter
+
+print("[PATCH] Attempting to apply simplified Crafter world configuration patch...")
+
+# World configuration presets
+WORLD_CONFIGS = {
+    "easy": {
+        "name": "Easy Mode",
+        "description": "More resources, fewer enemies",
+        # Modify spawn probabilities by multiplying original values
+        "spawn_multipliers": {
+            "tree": 1.5,  # 50% more trees
+            "coal": 1.5,  # 50% more coal
+            "iron": 1.5,  # 50% more iron
+            "diamond": 3.0,  # 3x more diamonds
+            "cow": 2.0,  # 2x more cows
+            "zombie": 0.3,  # 70% fewer zombies
+            "skeleton": 0.2,  # 80% fewer skeletons
+        },
+        # Modify spawn distances
+        "spawn_distances": {
+            "zombie": 15,  # Farther away (default 10)
+            "skeleton": 10,  # Farther away (default varies)
+            "cow": 2,  # Closer (default 3)
+        },
+    },
+    "normal": {
+        "name": "Normal Mode",
+        "description": "Standard crafter experience",
+        "spawn_multipliers": {
+            "tree": 1.0,
+            "coal": 1.0,
+            "iron": 1.0,
+            "diamond": 1.0,
+            "cow": 1.0,
+            "zombie": 1.0,
+            "skeleton": 1.0,
+        },
+        "spawn_distances": {"zombie": 10, "skeleton": 7, "cow": 3},
+    },
+    "hard": {
+        "name": "Hard Mode",
+        "description": "Fewer resources, more enemies",
+        "spawn_multipliers": {
+            "tree": 0.5,  # 50% fewer trees
+            "coal": 0.5,  # 50% less coal
+            "iron": 0.5,  # 50% less iron
+            "diamond": 0.3,  # 70% fewer diamonds
+            "cow": 0.3,  # 70% fewer cows
+            "zombie": 3.0,  # 3x more zombies
+            "skeleton": 3.0,  # 3x more skeletons
+        },
+        "spawn_distances": {
+            "zombie": 5,  # Much closer
+            "skeleton": 4,  # Much closer
+            "cow": 8,  # Farther away
+        },
+    },
+    "peaceful": {
+        "name": "Peaceful Mode",
+        "description": "No enemies, more resources",
+        "spawn_multipliers": {
+            "tree": 2.0,
+            "coal": 2.0,
+            "iron": 2.0,
+            "diamond": 5.0,
+            "cow": 3.0,
+            "zombie": 0.0,  # No zombies
+            "skeleton": 0.0,  # No skeletons
+        },
+        "spawn_distances": {"zombie": 100, "skeleton": 100, "cow": 1},
+    },
+}
+
+# Store active configuration
+_active_config = WORLD_CONFIGS["normal"]
+_original_balance_chunk = None
+_last_loaded_config = None  # Track what was last loaded to avoid duplicate prints
+
+
+def load_world_config(
+    config_name: str = "normal", config_path: Optional[str] = None
+) -> Dict[str, Any]:
+    """Load world configuration."""
+    global _active_config, _last_loaded_config
+
+    # Create a config identifier
+    config_id = config_path if config_path else config_name
+
+    # Only print if configuration actually changed
+    if _last_loaded_config != config_id:
+        if config_path and os.path.exists(config_path):
+            with open(config_path, "r") as f:
+                _active_config = json.load(f)
+            # print(f"[PATCH] Loaded custom world config from {config_path}")
+        elif config_name in WORLD_CONFIGS:
+            _active_config = WORLD_CONFIGS[config_name]
+            # print(f"[PATCH] Loaded '{config_name}' world configuration")
+        else:
+            _active_config = WORLD_CONFIGS["normal"]
+            # print(f"[PATCH] Unknown config '{config_name}', using 'normal'")
+
+        _last_loaded_config = config_id
+    else:
+        # Configuration hasn't changed, just return the active one
+        if config_path and os.path.exists(config_path):
+            with open(config_path, "r") as f:
+                _active_config = json.load(f)
+        elif config_name in WORLD_CONFIGS:
+            _active_config = WORLD_CONFIGS[config_name]
+        else:
+            _active_config = WORLD_CONFIGS["normal"]
+
+    return _active_config
+
+
+# Patch world generation to use configuration
+original_generate_world = crafter.worldgen.generate_world
+
+
+def patched_generate_world(world, player):
+    """Patched world generation that applies spawn multipliers."""
+    # Apply configuration without modifying numpy RandomState
+    multipliers = _active_config.get("spawn_multipliers", {})
+    distances = _active_config.get("spawn_distances", {})
+
+    # Call original generation first
+    result = original_generate_world(world, player)
+
+    # Post-process to adjust spawns based on multipliers
+    # This is a simpler approach that modifies objects after generation
+    if multipliers:
+        # Remove some objects based on multipliers < 1.0
+        objects_to_remove = []
+        for obj in world._objects:
+            if obj is None or obj is player:
+                continue
+
+            obj_type = type(obj).__name__.lower()
+
+            # Check if we should remove this object based on multiplier
+            multiplier = 1.0
+            if "tree" in obj_type or hasattr(obj, "kind") and getattr(obj, "kind") == "tree":
+                multiplier = multipliers.get("tree", 1.0)
+            elif "cow" in obj_type:
+                multiplier = multipliers.get("cow", 1.0)
+            elif "zombie" in obj_type:
+                multiplier = multipliers.get("zombie", 1.0)
+            elif "skeleton" in obj_type:
+                multiplier = multipliers.get("skeleton", 1.0)
+
+            # Remove objects if multiplier < 1.0
+            if multiplier < 1.0 and world.random.random() > multiplier:
+                objects_to_remove.append(obj)
+
+        # Remove marked objects
+        for obj in objects_to_remove:
+            world.remove(obj)
+
+        # Add extra objects if multiplier > 1.0
+        # (This is more complex and would require spawning new objects)
+
+    # Post-process to adjust spawn distances
+    if distances:
+        # Adjust initial enemy positions based on distance config
+        for obj in list(world._objects):
+            if obj is None:
+                continue
+
+            obj_type = type(obj).__name__.lower()
+            if obj_type in distances:
+                min_dist = distances[obj_type]
+                player_pos = player.pos
+                obj_pos = obj.pos
+                dist = abs(obj_pos[0] - player_pos[0]) + abs(obj_pos[1] - player_pos[1])
+
+                if dist < min_dist:
+                    # Remove objects too close to player
+                    world.remove(obj)
+
+    return result
+
+
+# Patch the balance function for dynamic spawning
+def patched_balance_chunk(self, chunk, objs=None):
+    """Patched chunk balancing with config support."""
+    global _original_balance_chunk
+    if _original_balance_chunk is None:
+        return
+
+    multipliers = _active_config.get("spawn_multipliers", {})
+    distances = _active_config.get("spawn_distances", {})
+
+    # Call original balance function with objs parameter
+    if objs is not None:
+        _original_balance_chunk(self, chunk, objs)
+    else:
+        _original_balance_chunk(self, chunk)
+
+    # Post-process spawned objects based on multipliers
+    # Check if any new objects were spawned and adjust them
+    if multipliers:
+        # Get the chunk bounds
+        chunk_x = chunk[0] * self._world._chunk_size
+        chunk_y = chunk[1] * self._world._chunk_size
+        chunk_w = self._world._chunk_size
+        chunk_h = self._world._chunk_size
+
+        objects_to_remove = []
+        for obj in self._world._objects:
+            if obj is None:
+                continue
+
+            # Check if object is in this chunk
+            try:
+                pos_x, pos_y = obj.pos[0], obj.pos[1]
+                if chunk_x <= pos_x < chunk_x + chunk_w and chunk_y <= pos_y < chunk_y + chunk_h:
+                    obj_type = type(obj).__name__.lower()
+                    multiplier = 1.0
+
+                    if "zombie" in obj_type:
+                        multiplier = multipliers.get("zombie", 1.0)
+                    elif "skeleton" in obj_type:
+                        multiplier = multipliers.get("skeleton", 1.0)
+                    elif "cow" in obj_type:
+                        multiplier = multipliers.get("cow", 1.0)
+
+                    # Remove objects based on multiplier
+                    if multiplier < 1.0 and self._world.random.random() > multiplier:
+                        objects_to_remove.append(obj)
+            except (ValueError, AttributeError):
+                # Skip objects with invalid position data
+                continue
+
+        # Remove marked objects
+        for obj in objects_to_remove:
+            self._world.remove(obj)
+
+
+# Apply patches
+crafter.worldgen.generate_world = patched_generate_world
+
+# Store original balance_chunk
+_original_balance_chunk = crafter.Env._balance_chunk
+crafter.Env._balance_chunk = patched_balance_chunk
+
+# Extend Env.__init__ to accept world_config
+original_env_init = crafter.Env.__init__
+
+
+def patched_env_init(
+    self,
+    area=(64, 64),
+    view=(9, 9),
+    length=10000,
+    seed=None,
+    world_config="normal",
+    world_config_path=None,
+):
+    """Extended Env.__init__ that accepts world configuration."""
+    # Load configuration
+    load_world_config(world_config, world_config_path)
+
+    # Call original init
+    original_env_init(self, area=area, view=view, length=length, seed=seed)
+
+    # Store config name
+    self._world_config_name = world_config if not world_config_path else "custom"
+
+
+crafter.Env.__init__ = patched_env_init
+
+print("[PATCH] Simplified Crafter world configuration patch complete.")
+print("[PATCH] Available configs: easy, normal, hard, peaceful")
+
+# Example custom config
+EXAMPLE_CUSTOM_CONFIG = {
+    "name": "Custom Config",
+    "description": "My custom world",
+    "spawn_multipliers": {
+        "tree": 1.2,
+        "coal": 1.3,
+        "iron": 1.4,
+        "diamond": 2.0,
+        "cow": 1.5,
+        "zombie": 0.5,
+        "skeleton": 0.5,
+    },
+    "spawn_distances": {"zombie": 12, "skeleton": 8, "cow": 4},
+}

synth_ai/environments/examples/crafter_custom/__init__.py

@@ -0,0 +1,4 @@
+"""Custom Crafter environments with configurable world generation."""
+
+# Note: Registration happens in the service app.py file
+# This module just provides the CrafterCustomEnvironment class

synth_ai/environments/examples/crafter_custom/crafter/__init__.py

@@ -0,0 +1,7 @@
+from .env import Env
+from .recorder import Recorder
+from .config import WorldGenConfig, PRESETS
+from . import constants
+
+# Note: We don't register with gym since this is a custom version
+# Users should import directly from this module