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

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/utils/map_stitcher_singleton.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-"""
-Singleton manager for MapStitcher to ensure all components use the same instance.
-This prevents multiple MapStitcher instances from being created and ensures
-consistent map data across the application.
-"""
-
-import logging
-from utils.map_stitcher import MapStitcher
-
-logger = logging.getLogger(__name__)
-
-# The single global MapStitcher instance
-_map_stitcher_instance = None
-
-def get_instance():
-    """Get the singleton MapStitcher instance."""
-    global _map_stitcher_instance
-    if _map_stitcher_instance is None:
-        _map_stitcher_instance = MapStitcher()
-        logger.info(f"Created singleton MapStitcher with {len(_map_stitcher_instance.map_areas)} areas")
-    elif len(_map_stitcher_instance.map_areas) == 0:
-        # If we have no data, reload from cache file in case it was updated
-        _map_stitcher_instance.load_from_file()
-        if len(_map_stitcher_instance.map_areas) > 0:
-            logger.info(f"Reloaded MapStitcher from cache, now has {len(_map_stitcher_instance.map_areas)} areas")
-    return _map_stitcher_instance
-
-def reset_instance():
-    """Reset the singleton instance (mainly for testing)."""
-    global _map_stitcher_instance
-    _map_stitcher_instance = None
-    logger.info("Reset MapStitcher singleton instance")

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/utils/map_trimmer.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""
-Map Trimming Utility
-
-Removes unnecessary padding from maps - rows/columns that are all walls (#)
-with no meaningful content should be trimmed.
-"""
-
-def trim_map_padding(grid_dict):
-    """
-    Trim unnecessary padding from a map grid.
-    
-    Args:
-        grid_dict: Dictionary mapping (x, y) to symbols
-        
-    Returns:
-        Trimmed grid dictionary
-    """
-    if not grid_dict:
-        return grid_dict
-    
-    # Get bounds
-    all_coords = list(grid_dict.keys())
-    if not all_coords:
-        return grid_dict
-        
-    min_x = min(x for x, y in all_coords)
-    max_x = max(x for x, y in all_coords)
-    min_y = min(y for x, y in all_coords)
-    max_y = max(y for x, y in all_coords)
-    
-    # Check each edge to see if it can be trimmed
-    # A row/column can be trimmed if it's all # or empty
-    
-    # Check top rows
-    trim_top = 0
-    for y in range(min_y, max_y + 1):
-        row_values = [grid_dict.get((x, y), ' ') for x in range(min_x, max_x + 1)]
-        # Skip if all walls or empty
-        if all(v in ['#', ' ', None] for v in row_values):
-            trim_top += 1
-        else:
-            break
-    
-    # Check bottom rows
-    trim_bottom = 0
-    for y in range(max_y, min_y - 1, -1):
-        row_values = [grid_dict.get((x, y), ' ') for x in range(min_x, max_x + 1)]
-        if all(v in ['#', ' ', None] for v in row_values):
-            trim_bottom += 1
-        else:
-            break
-    
-    # Check left columns
-    trim_left = 0
-    for x in range(min_x, max_x + 1):
-        col_values = [grid_dict.get((x, y), ' ') for y in range(min_y, max_y + 1)]
-        if all(v in ['#', ' ', None] for v in col_values):
-            trim_left += 1
-        else:
-            break
-    
-    # Check right columns
-    trim_right = 0
-    for x in range(max_x, min_x - 1, -1):
-        col_values = [grid_dict.get((x, y), ' ') for y in range(min_y, max_y + 1)]
-        if all(v in ['#', ' ', None] for v in col_values):
-            trim_right += 1
-        else:
-            break
-    
-    # But keep at least one row of walls around the actual content
-    # Don't trim if it would remove actual room walls
-    if trim_top > 1:
-        trim_top -= 1  # Keep one row of walls
-    if trim_bottom > 1:
-        trim_bottom -= 1
-    if trim_left > 1:
-        trim_left -= 1
-    if trim_right > 1:
-        trim_right -= 1
-    
-    # Create trimmed grid
-    trimmed = {}
-    new_min_x = min_x + trim_left
-    new_max_x = max_x - trim_right
-    new_min_y = min_y + trim_top
-    new_max_y = max_y - trim_bottom
-    
-    for y in range(new_min_y, new_max_y + 1):
-        for x in range(new_min_x, new_max_x + 1):
-            if (x, y) in grid_dict:
-                # Adjust coordinates to start from 0
-                new_x = x - new_min_x
-                new_y = y - new_min_y
-                trimmed[(new_x, new_y)] = grid_dict[(x, y)]
-    
-    return trimmed
-
-
-def is_padding_row(row_values):
-    """Check if a row is just padding (all walls with no content)"""
-    # A padding row is one that's all # or empty spaces
-    # But not if it contains doors, NPCs, items, etc.
-    meaningful_symbols = ['.', 'D', 'N', 'T', 'P', 'S', 'W', '?', '~']
-    return not any(v in meaningful_symbols for v in row_values)

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/utils/map_visualizer.py

@@ -1,334 +0,0 @@
-#!/usr/bin/env python3
-"""
-Map Stitching Visualization System
-
-Creates visual representations of the stitched world map showing
-connections between different areas, routes, towns, and buildings.
-"""
-
-import logging
-from typing import Dict, List, Tuple, Optional, Any, Set
-from utils.map_stitcher import MapStitcher, WarpConnection, MapArea
-from utils.map_formatter import format_map_for_display, get_symbol_legend
-
-logger = logging.getLogger(__name__)
-
-class MapVisualizer:
-    """Visualizes stitched map connections and layouts"""
-    
-    def __init__(self, map_stitcher: MapStitcher):
-        self.stitcher = map_stitcher
-    
-    def generate_world_map_summary(self) -> str:
-        """Generate a text summary of the entire stitched world"""
-        stats = self.stitcher.get_stats()
-        lines = [
-            "=== STITCHED WORLD MAP SUMMARY ===",
-            "",
-            f"📍 Total Areas Discovered: {stats['total_areas']}",
-            f"   🏠 Indoor Areas: {stats['indoor_areas']}",
-            f"   🌍 Outdoor Areas: {stats['outdoor_areas']}",
-            f"",
-            f"🔗 Total Connections: {stats['total_connections']}",
-        ]
-        
-        # Show warp type breakdown
-        if stats['warp_types']:
-            lines.append("   Warp Types:")
-            for warp_type, count in stats['warp_types'].items():
-                lines.append(f"     {warp_type}: {count}")
-        
-        lines.extend([
-            "",
-            f"⭐ Most Visited: {stats.get('most_visited', 'None')}",
-            ""
-        ])
-        
-        return "\n".join(lines)
-    
-    def generate_area_connections_map(self, focus_area_id: Optional[int] = None) -> str:
-        """Generate a connection map showing how areas link together"""
-        lines = ["=== AREA CONNECTIONS MAP ===", ""]
-        
-        if focus_area_id:
-            # Show connections for a specific area
-            area = self.stitcher.map_areas.get(focus_area_id)
-            if not area:
-                return "Area not found"
-                
-            lines.append(f"🎯 FOCUS: {area.location_name} (ID: {focus_area_id:04X})")
-            lines.append("")
-            
-            connections = self.stitcher.get_connected_areas(focus_area_id)
-            if connections:
-                lines.append("Connected Areas:")
-                for to_id, to_name, direction in connections:
-                    direction_symbol = self._get_direction_symbol(direction)
-                    lines.append(f"  {direction_symbol} {to_name} (ID: {to_id:04X})")
-            else:
-                lines.append("  No connections found")
-        else:
-            # Show all areas and their connection counts
-            lines.append("All Areas (with connection counts):")
-            lines.append("")
-            
-            for area_id, area in self.stitcher.map_areas.items():
-                connections = self.stitcher.get_connected_areas(area_id)
-                connection_count = len(connections)
-                
-                area_type = "🏠" if area.location_name and "HOUSE" in area.location_name.upper() else "🌍"
-                lines.append(f"{area_type} {area.location_name} ({area_id:04X}) - {connection_count} connections")
-                
-                if connections:
-                    for to_id, to_name, direction in connections[:3]:  # Show first 3
-                        direction_symbol = self._get_direction_symbol(direction)
-                        lines.append(f"    {direction_symbol} {to_name}")
-                    if len(connections) > 3:
-                        lines.append(f"    ... and {len(connections) - 3} more")
-        
-        return "\n".join(lines)
-    
-    def generate_route_network_map(self) -> str:
-        """Generate a network view of route connections"""
-        lines = ["=== ROUTE NETWORK MAP ===", ""]
-        
-        # Group areas by type
-        routes = []
-        towns = []
-        buildings = []
-        
-        for area_id, area in self.stitcher.map_areas.items():
-            name = area.location_name.upper() if area.location_name else "UNKNOWN"
-            if "ROUTE" in name:
-                routes.append((area_id, area))
-            elif any(keyword in name for keyword in ["TOWN", "CITY"]):
-                towns.append((area_id, area))
-            elif any(keyword in name for keyword in ["HOUSE", "ROOM", "CENTER", "MART", "GYM"]):
-                buildings.append((area_id, area))
-        
-        if routes:
-            lines.append("🛤️  ROUTES:")
-            for area_id, area in sorted(routes, key=lambda x: x[1].location_name):
-                connections = self.stitcher.get_connected_areas(area_id)
-                connection_names = [name for _, name, _ in connections]
-                lines.append(f"  {area.location_name} → {', '.join(connection_names[:3])}")
-        
-        if towns:
-            lines.append("")
-            lines.append("🏘️  TOWNS & CITIES:")
-            for area_id, area in sorted(towns, key=lambda x: x[1].location_name):
-                connections = self.stitcher.get_connected_areas(area_id)
-                route_connections = [name for _, name, _ in connections if "ROUTE" in name.upper()]
-                if route_connections:
-                    lines.append(f"  {area.location_name} ↔ {', '.join(route_connections)}")
-                else:
-                    lines.append(f"  {area.location_name} (isolated)")
-        
-        if buildings:
-            lines.append("")
-            lines.append("🏢 BUILDINGS:")
-            building_count_by_area = {}
-            for area_id, area in buildings:
-                # Group buildings by their location area
-                connections = self.stitcher.get_connected_areas(area_id)
-                parent_areas = [name for _, name, _ in connections 
-                              if not any(kw in name.upper() for kw in ["HOUSE", "ROOM", "CENTER"])]
-                parent = parent_areas[0] if parent_areas else "Unknown"
-                if parent not in building_count_by_area:
-                    building_count_by_area[parent] = []
-                building_count_by_area[parent].append(area.location_name)
-            
-            for parent, buildings_list in building_count_by_area.items():
-                lines.append(f"  {parent}: {len(buildings_list)} buildings")
-                for building in buildings_list[:3]:  # Show first 3
-                    lines.append(f"    • {building}")
-                if len(buildings_list) > 3:
-                    lines.append(f"    • ... and {len(buildings_list) - 3} more")
-        
-        return "\n".join(lines)
-    
-    def generate_warp_details_report(self) -> str:
-        """Generate detailed warp connection information"""
-        lines = ["=== WARP CONNECTIONS DETAILS ===", ""]
-        
-        # Group connections by type
-        warp_by_type = {}
-        for conn in self.stitcher.warp_connections:
-            if conn.warp_type not in warp_by_type:
-                warp_by_type[conn.warp_type] = []
-            warp_by_type[conn.warp_type].append(conn)
-        
-        for warp_type, connections in warp_by_type.items():
-            type_symbol = self._get_warp_type_symbol(warp_type)
-            lines.append(f"{type_symbol} {warp_type.upper()} CONNECTIONS ({len(connections)}):")
-            
-            for conn in connections[:10]:  # Show first 10 of each type
-                from_area = self.stitcher.map_areas.get(conn.from_map_id)
-                to_area = self.stitcher.map_areas.get(conn.to_map_id)
-                
-                if from_area and to_area:
-                    direction_symbol = self._get_direction_symbol(conn.direction)
-                    lines.append(f"  {direction_symbol} {from_area.location_name} → {to_area.location_name}")
-                    lines.append(f"    Position: ({conn.from_position[0]}, {conn.from_position[1]}) → ({conn.to_position[0]}, {conn.to_position[1]})")
-            
-            if len(connections) > 10:
-                lines.append(f"  ... and {len(connections) - 10} more {warp_type} connections")
-            
-            lines.append("")
-        
-        return "\n".join(lines)
-    
-    def generate_navigation_hints(self, current_area_id: int, target_area_name: str) -> str:
-        """Generate navigation hints to reach a target area"""
-        lines = [f"=== NAVIGATION: TO {target_area_name.upper()} ===", ""]
-        
-        current_area = self.stitcher.map_areas.get(current_area_id)
-        if not current_area:
-            return "Current area not found in stitched map"
-        
-        # Find target area
-        target_area = None
-        target_id = None
-        for area_id, area in self.stitcher.map_areas.items():
-            if area.location_name and target_area_name.upper() in area.location_name.upper():
-                target_area = area
-                target_id = area_id
-                break
-        
-        if not target_area:
-            lines.append(f"❌ Target area '{target_area_name}' not found in discovered areas")
-            lines.append("")
-            lines.append("Available areas:")
-            for area in self.stitcher.map_areas.values():
-                lines.append(f"  • {area.location_name}")
-            return "\n".join(lines)
-        
-        lines.append(f"📍 Current: {current_area.location_name}")
-        lines.append(f"🎯 Target: {target_area.location_name}")
-        lines.append("")
-        
-        # Simple pathfinding - direct connections first
-        direct_connections = self.stitcher.get_connected_areas(current_area_id)
-        direct_targets = [conn for conn in direct_connections if conn[0] == target_id]
-        
-        if direct_targets:
-            conn = direct_targets[0]
-            direction_symbol = self._get_direction_symbol(conn[2])
-            lines.append(f"🔗 Direct connection available!")
-            lines.append(f"   {direction_symbol} Go {conn[2]} to reach {target_area.location_name}")
-        else:
-            # Look for paths through connected areas
-            paths = self._find_simple_paths(current_area_id, target_id, max_depth=3)
-            if paths:
-                lines.append("🗺️  Possible routes:")
-                for i, path in enumerate(paths[:3]):  # Show first 3 paths
-                    route_description = self._describe_path(path)
-                    lines.append(f"   Route {i+1}: {route_description}")
-            else:
-                lines.append("❓ No known path found (areas may not be connected yet)")
-        
-        return "\n".join(lines)
-    
-    def _find_simple_paths(self, start_id: int, target_id: int, max_depth: int = 3) -> List[List[int]]:
-        """Find simple paths between areas (basic BFS)"""
-        if start_id == target_id:
-            return [[start_id]]
-        
-        visited = set()
-        queue = [(start_id, [start_id])]
-        paths = []
-        
-        while queue and len(paths) < 5:  # Limit to 5 paths
-            current_id, path = queue.pop(0)
-            
-            if len(path) > max_depth:
-                continue
-                
-            if current_id in visited:
-                continue
-                
-            visited.add(current_id)
-            
-            connections = self.stitcher.get_connected_areas(current_id)
-            for next_id, _, _ in connections:
-                if next_id == target_id:
-                    paths.append(path + [next_id])
-                elif next_id not in visited and len(path) < max_depth:
-                    queue.append((next_id, path + [next_id]))
-        
-        return paths
-    
-    def _describe_path(self, path: List[int]) -> str:
-        """Describe a path as a sequence of area names"""
-        if len(path) < 2:
-            return "No path"
-        
-        descriptions = []
-        for i in range(len(path) - 1):
-            from_id = path[i]
-            to_id = path[i + 1]
-            
-            from_area = self.stitcher.map_areas.get(from_id)
-            to_area = self.stitcher.map_areas.get(to_id)
-            
-            if from_area and to_area:
-                # Find the connection direction
-                connections = self.stitcher.get_connected_areas(from_id)
-                direction = "→"
-                for conn_id, _, conn_dir in connections:
-                    if conn_id == to_id:
-                        direction = self._get_direction_symbol(conn_dir)
-                        break
-                
-                descriptions.append(f"{from_area.location_name} {direction} {to_area.location_name}")
-        
-        return " → ".join(descriptions)
-    
-    def _get_direction_symbol(self, direction: str) -> str:
-        """Get symbol for direction"""
-        symbols = {
-            "north": "⬆️", "south": "⬇️", "east": "➡️", "west": "⬅️",
-            "up": "🔼", "down": "🔽", "northeast": "↗️", "northwest": "↖️",
-            "southeast": "↘️", "southwest": "↙️"
-        }
-        return symbols.get(direction.lower(), "🔄")
-    
-    def _get_warp_type_symbol(self, warp_type: str) -> str:
-        """Get symbol for warp type"""
-        symbols = {
-            "door": "🚪", "stairs": "🪜", "warp": "🌀", 
-            "route_transition": "🛤️", "exit": "🚪"
-        }
-        return symbols.get(warp_type, "🔗")
-    
-    def generate_complete_world_overview(self) -> str:
-        """Generate a complete overview combining all visualization types"""
-        lines = [
-            "=" * 60,
-            "           POKEMON EMERALD WORLD MAP",
-            "                (Stitched View)",
-            "=" * 60,
-            "",
-            self.generate_world_map_summary(),
-            "",
-            self.generate_route_network_map(),
-            "",
-            self.generate_area_connections_map(),
-            "",
-            self.generate_warp_details_report(),
-            "",
-            "=" * 60,
-            f"Generated from {len(self.stitcher.map_areas)} discovered areas",
-            "=" * 60
-        ]
-        
-        return "\n".join(lines)
-
-def create_map_visualizer(memory_reader) -> MapVisualizer:
-    """Create a map visualizer from a memory reader's stitcher"""
-    if hasattr(memory_reader, '_map_stitcher'):
-        return MapVisualizer(memory_reader._map_stitcher)
-    else:
-        # Create a standalone stitcher
-        stitcher = MapStitcher()
-        return MapVisualizer(stitcher)