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

synth_ai/environments/examples/crafter_classic/trace_hooks_v3.py

@@ -1,228 +0,0 @@
-"""
-Trace hooks for Crafter Classic environment - v3 version.
-Updated to use the v3 tracing architecture with async support.
-"""
-
-from datetime import datetime
-from typing import Any, Dict, Optional, Set
-
-from synth_ai.tracing_v3.abstractions import BaseEvent, EnvironmentEvent
-from synth_ai.tracing_v3.hooks import HookManager
-
-# 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

@@ -1,299 +0,0 @@
-"""
-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 Any, Dict, 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

@@ -1,4 +0,0 @@
-"""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/agent_demos/__init__.py

@@ -1 +0,0 @@
-"""Agent demonstrations for custom Crafter environments."""