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

synth_ai/environments/examples/sokoban/environment.py

@@ -0,0 +1,228 @@
+from typing import List, Optional, Any, Dict, Union
+from pydantic import BaseModel
+import dataclasses
+
+from synth_ai.environments.examples.sokoban.engine import (
+    SokobanEngine,
+    SynthSokobanObservationCallable,
+    SokobanPrivateState,
+    SokobanPublicState,
+    SynthSokobanCheckpointObservationCallable,
+    SokobanEngineSnapshot,
+)
+from synth_ai.environments.environment.shared_engine import (
+    GetObservationCallable,
+    InternalObservation,
+)
+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 synth_ai.environments.environment.tools import (
+    AbstractTool,
+    EnvToolCall,
+    ToolResult,
+    TOOL_REGISTRY,
+    register_tool,
+)
+
+
+# --- Tool Definition ---
+class SokobanActionInput(BaseModel):
+    action: int
+
+
+class SokobanInteractTool(AbstractTool):
+    name = "interact"
+    description = "Performs an action (e.g., move) in the Sokoban environment."
+    call_schema = SokobanActionInput
+    result_schema = ToolResult
+
+    def __init__(self, engine: SokobanEngine):
+        self.engine = engine
+
+    async def __call__(self, call: EnvToolCall) -> ToolResult:
+        try:
+            validated_args = self.call_schema(**call.args)
+            priv_state, pub_state = await self.engine._step_engine(validated_args.action)
+            return ToolResult(
+                ok=True,
+                payload={
+                    "public": pub_state.to_dict(),
+                    "private": priv_state.to_dict(),
+                },
+            )
+        except Exception as e:
+            # Add current public state to payload for context in case of error
+            _, pub_state_on_error = self.engine.get_current_states_for_observation()
+            return ToolResult(
+                ok=False,
+                error=str(e),
+                payload={"public": pub_state_on_error.to_dict()},
+            )
+
+
+class SokobanEnvironment(StatefulEnvironment, ReproducibleEnvironment[SokobanEngine]):
+    def __init__(
+        self,
+        task_instance: TaskInstance,
+        custom_step_obs: Optional[GetObservationCallable] = None,
+        custom_ckpt_obs: Optional[GetObservationCallable] = None,
+    ):
+        self.name = "Sokoban"
+        self.task_instance = task_instance
+        # Default to SynthSokobanObservationCallable if none provided
+        self.custom_step_observation_callable = custom_step_obs or SynthSokobanObservationCallable()
+        self.custom_checkpoint_observation_callable = (
+            custom_ckpt_obs or SynthSokobanCheckpointObservationCallable()
+        )
+        self.engine: SokobanEngine = SokobanEngine(task_instance)
+
+        self._interact_tool = SokobanInteractTool(self.engine)
+        if self._interact_tool.name not in TOOL_REGISTRY:
+            register_tool(self._interact_tool)
+        # elif getattr(TOOL_REGISTRY[self._interact_tool.name], 'engine', None) is not self.engine:
+        # register_tool(self._interact_tool) # More robust check if tool has engine attr
+
+    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 terminate(self) -> InternalObservation:
+        priv, pub = self.engine.get_current_states_for_observation()
+        priv.terminated = True  # Mark as terminated
+        obs_dict = {"terminated": True, "message": "Environment terminated."}
+        # Use _to_observation to format, including final state
+        return await self._to_observation(
+            priv, pub, self.custom_step_observation_callable, extra_obs=obs_dict
+        )
+
+    def validate_tool_calls(
+        self,
+        tool_calls: Union[
+            EnvToolCall,
+            List[Dict[str, Any]],
+            List[List[Dict[str, Any]]],
+            Dict[str, Any],
+        ],
+    ) -> EnvToolCall:
+        # Normalize and validate to a single EnvToolCall
+        raw_call_data: Dict[str, Any]
+        if isinstance(tool_calls, list):
+            if not tool_calls:
+                raise ValueError("Received empty list of tool calls.")
+            first_item = tool_calls[0]
+            if isinstance(first_item, list):
+                if not first_item:
+                    raise ValueError("Received empty inner list of tool calls.")
+                raw_call_data = first_item[0]
+            elif isinstance(first_item, dict):
+                raw_call_data = first_item
+            elif isinstance(first_item, EnvToolCall):  # Already an EnvToolCall instance
+                agent_call = first_item  # Assuming direct single call if already instance
+                if agent_call.tool != "interact":
+                    raise ValueError(f"Unknown tool: {agent_call.tool}. Expected 'interact'.")
+                return agent_call
+            else:
+                raise TypeError(f"Unexpected type in tool_calls list: {type(first_item)}")
+        elif isinstance(tool_calls, dict):  # Single call passed as dict
+            raw_call_data = tool_calls
+        elif isinstance(tool_calls, EnvToolCall):  # Single call already an instance
+            if tool_calls.tool != "interact":
+                raise ValueError(f"Unknown tool: {tool_calls.tool}. Expected 'interact'.")
+            return tool_calls
+        else:
+            raise TypeError(f"Unexpected type for tool_calls: {type(tool_calls)}")
+
+        if not isinstance(raw_call_data, dict):
+            raise TypeError(f"Processed call data is not a dict: {type(raw_call_data)}")
+
+        # Convert dict to EnvToolCall instance
+        tool_name = raw_call_data.get("tool")
+        tool_args = raw_call_data.get("args", {})
+        if tool_name != "interact":
+            raise ValueError(f"Unknown tool: {tool_name}. Expected 'interact'.")
+
+        agent_call = EnvToolCall(tool=tool_name, args=tool_args)
+        return agent_call
+
+    async def step(
+        self,
+        tool_calls: Union[
+            EnvToolCall,
+            List[Dict[str, Any]],
+            List[List[Dict[str, Any]]],
+            Dict[str, Any],
+        ],
+    ) -> InternalObservation:
+        agent_call = self.validate_tool_calls(tool_calls)
+        tool_result: ToolResult = await self._interact_tool(agent_call)
+
+        payload_dict = tool_result.payload
+        if not tool_result.ok or not isinstance(payload_dict, dict):  # Check tool_result.ok
+            # Fallback if payload isn't as expected or tool reported an error
+            priv_state, pub_state = self.engine.get_current_states_for_observation()
+            if tool_result.error and hasattr(pub_state, "error_info"):
+                pub_state.error_info = tool_result.error
+        else:
+            # This block assumes tool_result.ok is True and payload is a dict
+            priv_dict = payload_dict.get("private")
+            pub_dict = payload_dict.get("public")
+
+            if priv_dict is None or pub_dict is None:
+                # This case should ideally not happen if tool_result.ok is True
+                # and the tool is well-behaved, but as a safeguard:
+                priv_state, pub_state = self.engine.get_current_states_for_observation()
+                if tool_result.error and hasattr(
+                    pub_state, "error_info"
+                ):  # Apply error even in this sub-optimal case
+                    pub_state.error_info = tool_result.error
+            else:
+                priv_state = SokobanPrivateState(**priv_dict)
+                pub_state = SokobanPublicState(**pub_dict)
+                if tool_result.error and hasattr(pub_state, "error_info"):
+                    pub_state.error_info = tool_result.error
+
+        return await self._to_observation(
+            priv_state, pub_state, self.custom_step_observation_callable
+        )
+
+    async def checkpoint(self) -> InternalObservation:
+        engine_snapshot: SokobanEngineSnapshot = await self.engine._serialize_engine()
+        # For checkpoint, we might want to convey the snapshot data differently.
+        # The existing _to_observation expects live priv/pub states.
+        # For now, using current live states for observation, plus snapshot.
+        priv, pub = self.engine.get_current_states_for_observation()
+        obs_data = await self._to_observation(
+            priv, pub, self.custom_checkpoint_observation_callable
+        )
+        if isinstance(obs_data, dict):
+            obs_data["engine_snapshot_data"] = (
+                engine_snapshot.model_dump()
+            )  # Add snapshot if obs is dict
+        return obs_data
+
+    async def _to_observation(
+        self,
+        priv: SokobanPrivateState,
+        pub: SokobanPublicState,
+        obs_cb: Optional[GetObservationCallable],
+        extra_obs: Optional[Dict[str, Any]] = None,  # For adding things like termination messages
+    ) -> InternalObservation:
+        # Ensure obs_cb is not None; use a default if necessary (though __init__ sets one)
+        active_obs_cb = obs_cb or SynthSokobanObservationCallable()
+        observation = await active_obs_cb.get_observation(pub, priv)
+        if extra_obs and isinstance(observation, dict):
+            observation.update(extra_obs)
+        return observation
+
+    async def _serialize_engine(self) -> SokobanEngineSnapshot:  # Changed type hint
+        return await self.engine._serialize_engine()
+
+    @classmethod
+    async def _deserialize_engine(
+        cls, snapshot: SokobanEngineSnapshot, task_instance: TaskInstance
+    ) -> "SokobanEnvironment":  # Changed type hint
+        eng = await SokobanEngine._deserialize_engine(snapshot, task_instance)
+        env = cls(task_instance)  # Uses task_instance from deserialized engine
+        env.engine = eng
+        return env

synth_ai/environments/examples/sokoban/generate_verified_puzzles.py

@@ -0,0 +1,438 @@
+#!/usr/bin/env python3
+"""
+Generate verified solvable Sokoban puzzles.
+
+This script creates 500 solvable Sokoban puzzles (100 each for 5 difficulty levels)
+and saves them as JSON. Each puzzle is verified to be solvable using BFS.
+"""
+
+import json
+import logging
+import numpy as np
+from typing import Dict, List, Tuple, Optional, Any, Set
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from synth_ai.environments.examples.sokoban.engine_helpers.room_utils import (
+    generate_room,
+    get_shortest_action_path,
+)
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SokobanPuzzle:
+    """Represents a verified solvable Sokoban puzzle."""
+
+    id: str
+    difficulty: str
+    num_boxes: int
+    dim_room: Tuple[int, int]
+    room_fixed: List[List[int]]
+    room_state: List[List[int]]
+    box_mapping: Dict[str, List[int]]
+    solution_path: List[int]
+    solution_length: int
+    generation_seed: int
+    max_steps: int
+
+
+# Define difficulty configurations
+DIFFICULTY_CONFIGS = {
+    "ultra_easy": {
+        "num_boxes": 1,
+        "dim_room": (5, 5),
+        "max_steps": 50,
+        "target_solution_length": (3, 8),
+        "search_depth": 30,
+    },
+    "easy": {
+        "num_boxes": 1,
+        "dim_room": (6, 6),
+        "max_steps": 80,
+        "target_solution_length": (8, 15),
+        "search_depth": 50,
+    },
+    "medium": {
+        "num_boxes": 2,
+        "dim_room": (7, 7),
+        "max_steps": 120,
+        "target_solution_length": (15, 30),
+        "search_depth": 80,
+    },
+    "hard": {
+        "num_boxes": 3,
+        "dim_room": (8, 8),
+        "max_steps": 200,
+        "target_solution_length": (30, 60),
+        "search_depth": 120,
+    },
+}
+
+
+def verify_puzzle_solvable(
+    room_fixed: np.ndarray, room_state: np.ndarray, max_depth: int = 200
+) -> Optional[List[int]]:
+    """
+    Verify that a puzzle is solvable using BFS and return the solution path.
+
+    Args:
+        room_fixed: The fixed room structure (walls, targets, floors)
+        room_state: The current room state (player, boxes)
+        max_depth: Maximum search depth
+
+    Returns:
+        List of actions if solvable, None if not solvable
+    """
+    try:
+        solution_path = get_shortest_action_path(room_fixed, room_state, MAX_DEPTH=max_depth)
+        return solution_path if solution_path else None
+    except Exception as e:
+        logger.warning(f"Error verifying puzzle: {e}")
+        return None
+
+
+def setup_instances_directory() -> Path:
+    """Create the instances directory if it doesn't exist."""
+    instances_dir = Path(__file__).parent / "instances"
+    instances_dir.mkdir(exist_ok=True)
+    return instances_dir
+
+
+def get_jsonl_path(instances_dir: Path, difficulty: str) -> Path:
+    """Get the JSONL file path for a difficulty level."""
+    return instances_dir / f"{difficulty}.jsonl"
+
+
+def save_puzzle_to_jsonl(puzzle: SokobanPuzzle, jsonl_path: Path):
+    """Save a single puzzle to a JSONL file."""
+    with open(jsonl_path, "a") as f:
+        f.write(json.dumps(asdict(puzzle), default=convert_numpy_types) + "\n")
+
+
+def convert_numpy_types(obj):
+    """Convert numpy types to Python types for JSON serialization."""
+    if isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")
+
+
+def load_existing_puzzles(jsonl_path: Path) -> Set[str]:
+    """Load existing puzzle IDs from a JSONL file."""
+    existing_ids = set()
+    if jsonl_path.exists():
+        with open(jsonl_path, "r") as f:
+            for line in f:
+                try:
+                    puzzle_data = json.loads(line.strip())
+                    existing_ids.add(puzzle_data["id"])
+                except json.JSONDecodeError:
+                    continue
+    return existing_ids
+
+
+def count_existing_puzzles(jsonl_path: Path) -> int:
+    """Count existing puzzles in a JSONL file."""
+    if not jsonl_path.exists():
+        return 0
+    with open(jsonl_path, "r") as f:
+        return sum(1 for line in f if line.strip())
+
+
+def generate_puzzle_for_difficulty(
+    difficulty: str, config: Dict, seed: int, puzzle_id: str
+) -> Optional[SokobanPuzzle]:
+    """
+    Generate a single puzzle for a given difficulty level.
+
+    Args:
+        difficulty: The difficulty level name
+        config: Configuration for this difficulty
+        seed: Random seed for generation
+        puzzle_id: Unique identifier for this puzzle
+
+    Returns:
+        SokobanPuzzle if successfully generated and verified, None otherwise
+    """
+    max_attempts = 20
+
+    for attempt in range(max_attempts):
+        current_seed = seed + attempt * 1000
+
+        try:
+            # Generate room
+            room_structure, room_state, box_mapping, action_sequence = generate_room(
+                dim=config["dim_room"],
+                initial_seed=current_seed,
+                num_boxes=config["num_boxes"],
+                search_depth=config["search_depth"],
+                num_steps=config["search_depth"] // 2,
+            )
+
+            # Verify solvability
+            solution_path = verify_puzzle_solvable(
+                room_structure, room_state, max_depth=config["max_steps"]
+            )
+
+            if solution_path is None:
+                logger.debug(f"Puzzle {puzzle_id} attempt {attempt + 1} not solvable")
+                continue
+
+            solution_length = len(solution_path)
+            target_min, target_max = config["target_solution_length"]
+
+            # Check if solution length is within desired range
+            if not (target_min <= solution_length <= target_max):
+                logger.debug(
+                    f"Puzzle {puzzle_id} attempt {attempt + 1} solution length {solution_length} not in range {target_min}-{target_max}"
+                )
+                continue
+
+            # Convert numpy arrays to lists for JSON serialization
+            room_fixed_list = room_structure.tolist()
+            room_state_list = room_state.tolist()
+
+            # Convert box mapping to serializable format
+            box_mapping_serializable = {}
+            for key, value in box_mapping.items():
+                if isinstance(key, tuple):
+                    # Convert numpy integers to regular integers
+                    key_str = f"{int(key[0])},{int(key[1])}"
+                    if isinstance(value, tuple):
+                        box_mapping_serializable[key_str] = [int(value[0]), int(value[1])]
+                    else:
+                        box_mapping_serializable[key_str] = value
+                else:
+                    box_mapping_serializable[str(key)] = value
+
+            puzzle = SokobanPuzzle(
+                id=puzzle_id,
+                difficulty=difficulty,
+                num_boxes=int(config["num_boxes"]),
+                dim_room=config["dim_room"],
+                room_fixed=room_fixed_list,
+                room_state=room_state_list,
+                box_mapping=box_mapping_serializable,
+                solution_path=[int(action) for action in solution_path],  # Convert to regular ints
+                solution_length=int(solution_length),
+                generation_seed=int(current_seed),
+                max_steps=int(config["max_steps"]),
+            )
+
+            logger.info(
+                f"Generated {difficulty} puzzle {puzzle_id} (seed: {current_seed}, solution length: {solution_length})"
+            )
+            return puzzle
+
+        except Exception as e:
+            logger.warning(f"Error generating puzzle {puzzle_id} attempt {attempt + 1}: {e}")
+            continue
+
+    logger.error(f"Failed to generate puzzle {puzzle_id} after {max_attempts} attempts")
+    return None
+
+
+def generate_all_puzzles(num_per_difficulty: int = 100) -> Dict[str, List[SokobanPuzzle]]:
+    """
+    Generate all puzzles for all difficulty levels with incremental saving.
+
+    Args:
+        num_per_difficulty: Number of puzzles to generate per difficulty level
+
+    Returns:
+        Dictionary mapping difficulty names to lists of puzzles
+    """
+    all_puzzles = {}
+    total_puzzles = 0
+
+    # Setup instances directory
+    instances_dir = setup_instances_directory()
+    logger.info(f"Using instances directory: {instances_dir}")
+
+    for difficulty, config in DIFFICULTY_CONFIGS.items():
+        jsonl_path = get_jsonl_path(instances_dir, difficulty)
+        existing_ids = load_existing_puzzles(jsonl_path)
+        existing_count = count_existing_puzzles(jsonl_path)
+
+        logger.info(f"Processing {difficulty} difficulty...")
+        logger.info(f"  Found {existing_count} existing puzzles")
+        logger.info(f"  Target: {num_per_difficulty} puzzles")
+
+        puzzles = []
+        base_seed = hash(difficulty) % 100000
+
+        # Generate puzzles until we have enough
+        i = 0
+        generated_this_run = 0
+        while (
+            len(puzzles) + existing_count < num_per_difficulty and i < num_per_difficulty * 5
+        ):  # Safety limit
+            puzzle_id = f"{difficulty}_{i:03d}"
+
+            # Skip if already exists
+            if puzzle_id in existing_ids:
+                i += 1
+                continue
+
+            puzzle = generate_puzzle_for_difficulty(
+                difficulty=difficulty, config=config, seed=base_seed + i, puzzle_id=puzzle_id
+            )
+
+            if puzzle:
+                puzzles.append(puzzle)
+                # Save immediately to JSONL
+                save_puzzle_to_jsonl(puzzle, jsonl_path)
+                generated_this_run += 1
+                total_puzzles += 1
+                logger.info(
+                    f"Generated and saved {difficulty} puzzle {puzzle_id} ({generated_this_run}/{num_per_difficulty - existing_count} new)"
+                )
+            else:
+                logger.warning(f"Failed to generate puzzle {puzzle_id}")
+
+            i += 1
+
+        all_puzzles[difficulty] = puzzles
+        logger.info(
+            f"Completed {difficulty}: {generated_this_run} new puzzles generated, {existing_count + len(puzzles)} total"
+        )
+
+    logger.info(f"Total new puzzles generated this run: {total_puzzles}")
+    return all_puzzles
+
+
+def load_all_puzzles_from_jsonl(instances_dir: Path) -> Dict[str, List[SokobanPuzzle]]:
+    """Load all puzzles from JSONL files."""
+    all_puzzles = {}
+
+    for difficulty in DIFFICULTY_CONFIGS.keys():
+        jsonl_path = get_jsonl_path(instances_dir, difficulty)
+        puzzles = []
+
+        if jsonl_path.exists():
+            with open(jsonl_path, "r") as f:
+                for line in f:
+                    try:
+                        puzzle_data = json.loads(line.strip())
+                        puzzle = SokobanPuzzle(
+                            id=puzzle_data["id"],
+                            difficulty=puzzle_data["difficulty"],
+                            num_boxes=puzzle_data["num_boxes"],
+                            dim_room=tuple(puzzle_data["dim_room"]),
+                            room_fixed=puzzle_data["room_fixed"],
+                            room_state=puzzle_data["room_state"],
+                            box_mapping=puzzle_data["box_mapping"],
+                            solution_path=puzzle_data["solution_path"],
+                            solution_length=puzzle_data["solution_length"],
+                            generation_seed=puzzle_data["generation_seed"],
+                            max_steps=puzzle_data["max_steps"],
+                        )
+                        puzzles.append(puzzle)
+                    except (json.JSONDecodeError, KeyError) as e:
+                        logger.warning(f"Error loading puzzle from {jsonl_path}: {e}")
+                        continue
+
+        all_puzzles[difficulty] = puzzles
+
+    return all_puzzles
+
+
+def save_puzzles_to_json(puzzles: Dict[str, List[SokobanPuzzle]], output_path: Path):
+    """
+    Save puzzles to JSON file.
+
+    Args:
+        puzzles: Dictionary of puzzles by difficulty
+        output_path: Path to save the JSON file
+    """
+    # Convert to serializable format
+    serializable_puzzles = {}
+    for difficulty, puzzle_list in puzzles.items():
+        serializable_puzzles[difficulty] = [asdict(puzzle) for puzzle in puzzle_list]
+
+    # Add metadata
+    output_data = {
+        "metadata": {
+            "version": "1.0",
+            "total_puzzles": sum(len(puzzles) for puzzles in serializable_puzzles.values()),
+            "difficulties": list(DIFFICULTY_CONFIGS.keys()),
+            "generated_at": "2024-01-01T00:00:00Z",  # Will be updated when actually generated
+        },
+        "puzzles": serializable_puzzles,
+    }
+
+    with open(output_path, "w") as f:
+        json.dump(output_data, f, indent=2, default=convert_numpy_types)
+
+    logger.info(f"Saved puzzles to {output_path}")
+
+
+def create_unified_json_from_jsonl():
+    """Create a unified JSON file from all JSONL files for the puzzle loader."""
+    instances_dir = setup_instances_directory()
+    all_puzzles = load_all_puzzles_from_jsonl(instances_dir)
+
+    # Save to JSON
+    output_path = Path(__file__).parent / "verified_puzzles.json"
+    save_puzzles_to_json(all_puzzles, output_path)
+
+    return all_puzzles
+
+
+def main():
+    """Main function to generate and save all puzzles."""
+    logger.info("Starting Sokoban puzzle generation with incremental saving...")
+
+    # Generate puzzles (saves incrementally to JSONL)
+    puzzles = generate_all_puzzles(num_per_difficulty=100)
+
+    # Print summary of this run
+    logger.info("Puzzle generation complete!")
+    logger.info("Summary of this run:")
+    for difficulty, puzzle_list in puzzles.items():
+        if puzzle_list:
+            avg_solution_length = sum(p.solution_length for p in puzzle_list) / len(puzzle_list)
+            logger.info(
+                f"  {difficulty}: {len(puzzle_list)} new puzzles, avg solution length: {avg_solution_length:.1f}"
+            )
+        else:
+            logger.info(f"  {difficulty}: 0 new puzzles")
+
+    # Show total counts from JSONL files
+    instances_dir = setup_instances_directory()
+    logger.info("Total puzzles saved:")
+    for difficulty in DIFFICULTY_CONFIGS.keys():
+        jsonl_path = get_jsonl_path(instances_dir, difficulty)
+        total_count = count_existing_puzzles(jsonl_path)
+        logger.info(f"  {difficulty}: {total_count} total puzzles")
+
+    # Create unified JSON file for the puzzle loader
+    logger.info("Creating unified JSON file for puzzle loader...")
+    create_unified_json_from_jsonl()
+    logger.info("Unified JSON file created successfully!")
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1 and sys.argv[1] == "--create-json":
+        # Just create the unified JSON from existing JSONL files
+        logger.info("Creating unified JSON file from existing JSONL files...")
+        puzzles = create_unified_json_from_jsonl()
+        logger.info("Summary of loaded puzzles:")
+        for difficulty, puzzle_list in puzzles.items():
+            if puzzle_list:
+                avg_solution_length = sum(p.solution_length for p in puzzle_list) / len(puzzle_list)
+                logger.info(
+                    f"  {difficulty}: {len(puzzle_list)} puzzles, avg solution length: {avg_solution_length:.1f}"
+                )
+            else:
+                logger.info(f"  {difficulty}: 0 puzzles")
+    else:
+        main()