localdex 0.1.8__py3-none-any.whl → 0.1.19__py3-none-any.whl

localdex/__init__.py

@@ -1,18 +1,9 @@
-"""
-LocalDex - A fast, offline-first Python library for Pokemon data access.
-
-This package provides comprehensive Pokemon information without requiring
-network requests, making it perfect for applications that need reliable,
-fast access to Pokemon data.
-"""
-
-__version__ = "0.1.0"
-__author__ = "LocalDex Team"
-__email__ = "localdex@example.com"
 
 from .core import LocalDex
 from .models import Pokemon, Move, Ability, Item, BaseStats
 from .exceptions import PokemonNotFoundError, MoveNotFoundError, AbilityNotFoundError, ItemNotFoundError
+from .random_battles import RandomBattleSets
+from .sprite_downloader import SpriteDownloader
 
 __all__ = [
     "LocalDex",
@@ -25,4 +16,6 @@ __all__ = [
     "MoveNotFoundError", 
     "AbilityNotFoundError",
     "ItemNotFoundError",
+    "RandomBattleSets",
+    "SpriteDownloader",
 ] 

localdex/core.py

@@ -18,6 +18,8 @@ from .exceptions import (
     ItemNotFoundError, DataLoadError, SearchError
 )
 from .data_loader import DataLoader
+from .random_battles import RandomBattleSets
+from .sprite_downloader import SpriteDownloader
 
 
 class LocalDex:
@@ -29,7 +31,7 @@ class LocalDex:
     performance and comprehensive search capabilities.
     """
     
-    def __init__(self, data_path: Optional[str] = None, data_dir: Optional[str] = None, enable_caching: bool = True):
+    def __init__(self, data_path: Optional[str] = None, data_dir: Optional[str] = None, enable_caching: bool = True, enable_random_battles: bool = True, enable_sprite_downloader: bool = True, sprite_max_workers: int = 8):
         """
         Initialize the LocalDex.
         
@@ -37,6 +39,9 @@ class LocalDex:
             data_path: Optional path to data directory. If None, uses package data.
             data_dir: Alias for data_path for backward compatibility.
             enable_caching: Whether to enable caching for better performance.
+            enable_random_battles: Whether to enable random battle sets functionality.
+            enable_sprite_downloader: Whether to enable sprite downloader functionality.
+            sprite_max_workers: Maximum number of worker threads for parallel sprite processing.
         """
         # Use data_dir if provided, otherwise use data_path
         final_data_path = data_dir if data_dir is not None else data_path
@@ -44,6 +49,12 @@ class LocalDex:
         self.data_dir = final_data_path  # Store for backward compatibility
         self.enable_caching = enable_caching
         
+        # Sprite downloader integration
+        self.sprite_downloader = SpriteDownloader(final_data_path, max_workers=sprite_max_workers) if enable_sprite_downloader else None
+        
+        # Initialize random battle sets
+        self.random_battles = RandomBattleSets() if enable_random_battles else None
+        
         # Initialize caches
         self._pokemon_cache: Dict[str, Pokemon] = {}
         self._pokemon_id_cache: Dict[int, Pokemon] = {}
@@ -556,4 +567,178 @@ class LocalDex:
             "moves": len(self._move_cache),
             "abilities": len(self._ability_cache),
             "items": len(self._item_cache)
-        } 
+        }
+    
+    # Random Battle Sets Methods
+    
+    def get_random_battle_sets(self, pokemon_name: str, generation: int = 9, force_refresh: bool = False) -> Optional[Dict[str, Any]]:
+        """
+        Get random battle sets for a specific Pokemon.
+        
+        Args:
+            pokemon_name: Name of the Pokemon (case-insensitive)
+            generation: Generation to get sets from (8 or 9)
+            force_refresh: If True, re-download data
+            
+        Returns:
+            Pokemon's random battle sets or None if not found
+            
+        Raises:
+            ValueError: If random battles are not enabled
+        """
+        if self.random_battles is None:
+            raise ValueError("Random battle sets are not enabled. Set enable_random_battles=True when initializing LocalDex.")
+        
+        if generation == 9:
+            return self.random_battles.get_pokemon_gen9_sets(pokemon_name, force_refresh)
+        elif generation == 8:
+            return self.random_battles.get_pokemon_gen8_data(pokemon_name, force_refresh)
+        else:
+            raise ValueError(f"Generation {generation} is not supported. Use 8 or 9.")
+    
+    def get_all_random_battle_sets(self, generation: int = 9, force_refresh: bool = False) -> Dict[str, Any]:
+        """
+        Get all random battle sets for a generation.
+        
+        Args:
+            generation: Generation to get sets from (8 or 9)
+            force_refresh: If True, re-download data
+            
+        Returns:
+            Dictionary containing all random battle sets for the generation
+            
+        Raises:
+            ValueError: If random battles are not enabled
+        """
+        if self.random_battles is None:
+            raise ValueError("Random battle sets are not enabled. Set enable_random_battles=True when initializing LocalDex.")
+        
+        if generation == 9:
+            return self.random_battles.get_gen9_sets(force_refresh)
+        elif generation == 8:
+            return self.random_battles.get_gen8_data(force_refresh)
+        else:
+            raise ValueError(f"Generation {generation} is not supported. Use 8 or 9.")
+    
+    def search_random_battle_pokemon_by_move(self, move_name: str, generation: int = 9, force_refresh: bool = False) -> List[str]:
+        """
+        Search for Pokemon that have a specific move in their random battle sets.
+        
+        Args:
+            move_name: Name of the move to search for (case-insensitive)
+            generation: Generation to search in (8 or 9)
+            force_refresh: If True, re-download data
+            
+        Returns:
+            List of Pokemon names that have the move
+            
+        Raises:
+            ValueError: If random battles are not enabled
+        """
+        if self.random_battles is None:
+            raise ValueError("Random battle sets are not enabled. Set enable_random_battles=True when initializing LocalDex.")
+        
+        return self.random_battles.search_pokemon_by_move(move_name, generation, force_refresh)
+    
+    def search_random_battle_pokemon_by_ability(self, ability_name: str, generation: int = 9, force_refresh: bool = False) -> List[str]:
+        """
+        Search for Pokemon that have a specific ability in their random battle sets.
+        
+        Args:
+            ability_name: Name of the ability to search for (case-insensitive)
+            generation: Generation to search in (8 or 9)
+            force_refresh: If True, re-download data
+            
+        Returns:
+            List of Pokemon names that have the ability
+            
+        Raises:
+            ValueError: If random battles are not enabled
+        """
+        if self.random_battles is None:
+            raise ValueError("Random battle sets are not enabled. Set enable_random_battles=True when initializing LocalDex.")
+        
+        return self.random_battles.search_pokemon_by_ability(ability_name, generation, force_refresh)
+    
+    def get_available_random_battle_generations(self) -> List[int]:
+        """
+        Get list of available generations for random battles.
+        
+        Returns:
+            List of generation numbers
+            
+        Raises:
+            ValueError: If random battles are not enabled
+        """
+        if self.random_battles is None:
+            raise ValueError("Random battle sets are not enabled. Set enable_random_battles=True when initializing LocalDex.")
+        
+        return self.random_battles.get_available_generations()
+    
+    def get_random_battle_formats(self, generation: int) -> List[str]:
+        """
+        Get available formats for a specific generation.
+        
+        Args:
+            generation: Generation number
+            
+        Returns:
+            List of available format names
+            
+        Raises:
+            ValueError: If random battles are not enabled
+        """
+        if self.random_battles is None:
+            raise ValueError("Random battle sets are not enabled. Set enable_random_battles=True when initializing LocalDex.")
+        
+        return self.random_battles.get_generation_formats(generation)
+    
+    def clear_random_battle_cache(self) -> None:
+        """Clear random battle cache."""
+        if self.random_battles is not None:
+            self.random_battles.clear_cache()
+    
+    def cleanup_random_battle_downloads(self) -> None:
+        """Remove downloaded Pokemon Showdown repository."""
+        if self.random_battles is not None:
+            self.random_battles.cleanup_downloads()
+    
+    def download_all_sprites(self):
+        """
+        Download and extract all sprites (Pokemon and items).
+        """
+        if not self.sprite_downloader:
+            raise RuntimeError("SpriteDownloader is not enabled.")
+        return self.sprite_downloader.download_all_sprites()
+
+    def get_pokemon_sprite_path(self, pokemon_name: str):
+        """
+        Get the path to a Pokemon sprite image.
+        """
+        if not self.sprite_downloader:
+            raise RuntimeError("SpriteDownloader is not enabled.")
+        return self.sprite_downloader.get_pokemon_sprite_path(pokemon_name)
+
+    def get_item_sprite_path(self, item_name: str):
+        """
+        Get the path to an item sprite image.
+        """
+        if not self.sprite_downloader:
+            raise RuntimeError("SpriteDownloader is not enabled.")
+        return self.sprite_downloader.get_item_sprite_path(item_name)
+
+    def get_sprite_metadata(self, sprite_type: str = "pokemon"):
+        """
+        Get sprite metadata for either 'pokemon' or 'items'.
+        """
+        if not self.sprite_downloader:
+            raise RuntimeError("SpriteDownloader is not enabled.")
+        return self.sprite_downloader.get_sprite_metadata(sprite_type)
+
+    def list_available_sprites(self, sprite_type: str = "pokemon"):
+        """
+        List all available sprites of a given type ('pokemon' or 'items').
+        """
+        if not self.sprite_downloader:
+            raise RuntimeError("SpriteDownloader is not enabled.")
+        return self.sprite_downloader.list_available_sprites(sprite_type) 

localdex/random_battles.py

@@ -0,0 +1,251 @@
+"""
+Random Battle Sets functionality for LocalDex.
+
+This module provides functionality to download and parse Pokemon Showdown's
+random battle sets from different generations and formats.
+"""
+
+import json
+import os
+import tempfile
+from typing import Dict, List, Optional, Any, Union
+from urllib.request import urlopen
+
+from .exceptions import DataLoadError
+
+
+class RandomBattleSets:
+    """
+    Handles downloading and parsing Pokemon Showdown random battle sets.
+    
+    This class provides methods to download random battle data from the
+    pkmn.github.io/randbats API and parse it into a usable format.
+    """
+    
+    # URLs for random battle data
+    GEN8_URL = "https://pkmn.github.io/randbats/data/gen8randombattle.json"
+    GEN9_URL = "https://pkmn.github.io/randbats/data/gen9randombattle.json"
+    
+    def __init__(self, cache_dir: Optional[str] = None):
+        """
+        Initialize the RandomBattleSets handler.
+        
+        Args:
+            cache_dir: Directory to cache downloaded data. If None, uses temp directory.
+        """
+        self.cache_dir = cache_dir or os.path.join(tempfile.gettempdir(), "localdex_random_battles")
+        
+        # Ensure cache directory exists
+        os.makedirs(self.cache_dir, exist_ok=True)
+        
+        # Cache for loaded data
+        self._gen9_sets_cache: Optional[Dict[str, Any]] = None
+        self._gen8_data_cache: Optional[Dict[str, Any]] = None
+    
+    def _download_json_data(self, url: str, cache_file: str, force_refresh: bool = False) -> Dict[str, Any]:
+        """
+        Download JSON data from URL and cache it locally.
+        
+        Args:
+            url: URL to download from
+            cache_file: Local cache file path
+            force_refresh: If True, re-download even if already cached
+            
+        Returns:
+            Downloaded data as dictionary
+            
+        Raises:
+            DataLoadError: If download fails
+        """
+        # Check if we have cached data and don't need to refresh
+        if os.path.exists(cache_file) and not force_refresh:
+            try:
+                with open(cache_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError):
+                # If cache is corrupted, remove it and re-download
+                pass
+        
+        try:
+            print(f"Downloading random battle data from {url}...")
+            with urlopen(url) as response:
+                data = json.loads(response.read().decode('utf-8'))
+            
+            # Cache the data
+            with open(cache_file, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2)
+            
+            print("Random battle data downloaded successfully!")
+            return data
+            
+        except Exception as e:
+            raise DataLoadError(f"Failed to download data from {url}: {e}")
+    
+    def get_gen9_sets(self, force_refresh: bool = False) -> Dict[str, Any]:
+        """
+        Get Generation 9 random battle sets.
+        
+        Args:
+            force_refresh: If True, re-download data
+            
+        Returns:
+            Dictionary containing Gen 9 random battle sets
+        """
+        if self._gen9_sets_cache is not None and not force_refresh:
+            return self._gen9_sets_cache
+        
+        cache_file = os.path.join(self.cache_dir, "gen9_randombattle.json")
+        data = self._download_json_data(self.GEN9_URL, cache_file, force_refresh)
+        
+        self._gen9_sets_cache = data
+        return data
+    
+    def get_gen8_data(self, force_refresh: bool = False) -> Dict[str, Any]:
+        """
+        Get Generation 8 random battle data.
+        
+        Args:
+            force_refresh: If True, re-download data
+            
+        Returns:
+            Dictionary containing Gen 8 random battle data
+        """
+        if self._gen8_data_cache is not None and not force_refresh:
+            return self._gen8_data_cache
+        
+        cache_file = os.path.join(self.cache_dir, "gen8_randombattle.json")
+        data = self._download_json_data(self.GEN8_URL, cache_file, force_refresh)
+        
+        self._gen8_data_cache = data
+        return data
+    
+
+    
+    def get_pokemon_gen9_sets(self, pokemon_name: str, force_refresh: bool = False) -> Optional[Dict[str, Any]]:
+        """
+        Get Generation 9 random battle sets for a specific Pokemon.
+        
+        Args:
+            pokemon_name: Name of the Pokemon (case-insensitive)
+            force_refresh: If True, re-download data
+            
+        Returns:
+            Pokemon's Gen 9 sets or None if not found
+        """
+        data = self.get_gen9_sets(force_refresh)
+        return data.get(pokemon_name.lower())
+    
+    def get_pokemon_gen8_data(self, pokemon_name: str, force_refresh: bool = False) -> Optional[Dict[str, Any]]:
+        """
+        Get Generation 8 random battle data for a specific Pokemon.
+        
+        Args:
+            pokemon_name: Name of the Pokemon (case-insensitive)
+            force_refresh: If True, re-download data
+            
+        Returns:
+            Pokemon's Gen 8 data or None if not found
+        """
+        data = self.get_gen8_data(force_refresh)
+        return data.get(pokemon_name.lower())
+    
+    def search_pokemon_by_move(self, move_name: str, generation: int = 9, force_refresh: bool = False) -> List[str]:
+        """
+        Search for Pokemon that have a specific move in their random battle sets.
+        
+        Args:
+            move_name: Name of the move to search for (case-insensitive)
+            generation: Generation to search in (8 or 9)
+            force_refresh: If True, re-download data
+            
+        Returns:
+            List of Pokemon names that have the move
+        """
+        move_name_lower = move_name.lower()
+        results = []
+        
+        if generation == 9:
+            data = self.get_gen9_sets(force_refresh)
+            for pokemon_name, pokemon_data in data.items():
+                if 'moves' in pokemon_data:
+                    if any(move.lower() == move_name_lower for move in pokemon_data['moves']):
+                        results.append(pokemon_name)
+        elif generation == 8:
+            data = self.get_gen8_data(force_refresh)
+            for pokemon_name, pokemon_data in data.items():
+                if 'moves' in pokemon_data:
+                    if any(move.lower() == move_name_lower for move in pokemon_data['moves']):
+                        results.append(pokemon_name)
+        
+        return results
+    
+    def search_pokemon_by_ability(self, ability_name: str, generation: int = 9, force_refresh: bool = False) -> List[str]:
+        """
+        Search for Pokemon that have a specific ability in their random battle sets.
+        
+        Args:
+            ability_name: Name of the ability to search for (case-insensitive)
+            generation: Generation to search in (8 or 9)
+            force_refresh: If True, re-download data
+            
+        Returns:
+            List of Pokemon names that have the ability
+        """
+        ability_name_lower = ability_name.lower()
+        results = []
+        
+        if generation == 9:
+            data = self.get_gen9_sets(force_refresh)
+            for pokemon_name, pokemon_data in data.items():
+                if 'abilities' in pokemon_data:
+                    if any(ability.lower() == ability_name_lower for ability in pokemon_data['abilities']):
+                        results.append(pokemon_name)
+        elif generation == 8:
+            data = self.get_gen8_data(force_refresh)
+            for pokemon_name, pokemon_data in data.items():
+                if 'abilities' in pokemon_data:
+                    if any(ability.lower() == ability_name_lower for ability in pokemon_data['abilities']):
+                        results.append(pokemon_name)
+        
+        return results
+    
+    def get_available_generations(self) -> List[int]:
+        """
+        Get list of available generations in the downloaded data.
+        
+        Returns:
+            List of generation numbers
+        """
+        return [8, 9]  # Only Gen 8 and 9 are available via the API
+    
+    def get_generation_formats(self, generation: int) -> List[str]:
+        """
+        Get available formats for a specific generation.
+        
+        Args:
+            generation: Generation number
+            
+        Returns:
+            List of available format names
+        """
+        if generation in [8, 9]:
+            return ["randombattle"]  # Only random battle format is available via the API
+        return []
+    
+    def clear_cache(self) -> None:
+        """Clear all cached data."""
+        self._gen9_sets_cache = None
+        self._gen8_data_cache = None
+    
+    def cleanup_downloads(self) -> None:
+        """Remove downloaded cache files."""
+        cache_files = [
+            os.path.join(self.cache_dir, "gen8_randombattle.json"),
+            os.path.join(self.cache_dir, "gen9_randombattle.json")
+        ]
+        
+        for cache_file in cache_files:
+            if os.path.exists(cache_file):
+                os.remove(cache_file)
+        
+        self.clear_cache()