localdex 0.2.40__py3-none-any.whl → 0.2.45__py3-none-any.whl

localdex/core.py

@@ -6,10 +6,11 @@ Pokemon data with caching, search capabilities, and data loading.
 """
 
 import json
+import math
 import os
 import glob
 from pathlib import Path
-from typing import Dict, List, Optional, Union, Any, Set
+from typing import Dict, List, Optional, Union, Any, Set, Tuple
 from functools import lru_cache
 
 from .models import Pokemon, Move, Ability, Item, BaseStats
@@ -435,8 +436,8 @@ class LocalDex:
             hp=base_stats_data.get("hp", 0),
             attack=base_stats_data.get("attack", 0),
             defense=base_stats_data.get("defense", 0),
-            special_attack=base_stats_data.get("special-attack", 0),
-            special_defense=base_stats_data.get("special-defense", 0),
+            special_attack=base_stats_data.get("special_attack", 0),
+            special_defense=base_stats_data.get("special_defense", 0),
             speed=base_stats_data.get("speed", 0),
         )
         return Pokemon(
@@ -510,7 +511,7 @@ class LocalDex:
         """Create an Item object from raw data."""
         return Item(
             name=data.get("name", ""),
-            description=data.get("desc"),
+            description=data.get("description", data.get("desc", "")),
             short_description=data.get("shortDesc"),
             generation=data.get("gen"),
             num=data.get("num"),
@@ -548,5 +549,671 @@ class LocalDex:
             "abilities": len(self._ability_cache),
             "items": len(self._item_cache)
         }
+    def get_base_stats_from_species(self, species: str):
+        """Get base stats from species name"""
+        return self.get_pokemon(name_or_id=species).base_stats
+    
+    def get_hp_stat_from_species(self, species: str, iv: int, ev: int, level: int = 100) -> int:
+        """Calculate HP stat for a species with given IVs, EVs, and level"""
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_hp(base_stats.hp, iv, ev, level)
+
+    def get_attack_stat_from_species(self, species: str, iv: int, ev: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """Calculate Attack stat for a species with given IVs, EVs, and level"""
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_other_stat(base_stats.attack, iv, ev, level, nature_modifier)
+    
+    def get_defense_stat_from_species(self, species: str, iv: int, ev: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """Calculate Defense stat for a species with given IVs, EVs, and level"""
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_other_stat(base_stats.defense, iv, ev, level, nature_modifier)
+    
+    def get_special_attack_stat_from_species(self, species: str, iv: int, ev: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """Calculate Special Attack stat for a species with given IVs, EVs, and level"""
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_other_stat(base_stats.special_attack, iv, ev, level, nature_modifier)
+    
+    def get_special_defense_stat_from_species(self, species: str, iv: int, ev: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """Calculate Special Defense stat for a species with given IVs, EVs, and level"""
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_other_stat(base_stats.special_defense, iv, ev, level, nature_modifier)
+    
+    def get_speed_stat_from_species(self, species: str, iv: int, ev: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """Calculate Speed stat for a species with given IVs, EVs, and level"""
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_other_stat(base_stats.speed, iv, ev, level, nature_modifier)
+    
+    def get_substitute_health_from_species(self, species: str, iv: int, ev: int, level: int = 100) -> int:
+        """Calculate substitute health for a species (1/4 of max HP)"""
+        max_hp = self.get_hp_stat_from_species(species, iv, ev, level)
+        return int(max_hp / 4)
+    
+    def calculate_hp(self, base: int, iv: int, ev: int, level: int = 100) -> int:
+        """
+        Calculate HP using the Pokemon HP formula.
+        
+        Args:
+            base (int): Base HP stat
+            iv (int): Individual Value (0-31)
+            ev (int): Effort Value (0-252)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            int: Calculated HP value
+        """
+        hp = math.floor(((2 * base + iv + math.floor(ev / 4)) * level) / 100) + level + 10
+        return hp
+        
+    def calculate_other_stat(self, base: int, iv: int, ev: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate other stats (Attack, Defense, Sp. Attack, Sp. Defense, Speed) using the Pokemon stat formula.
+        
+        Args:
+            base (int): Base stat value
+            iv (int): Individual Value (0-31)
+            ev (int): Effort Value (0-252)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Calculated stat value
+        """
+        stat = math.floor((math.floor(((2 * base + iv + math.floor(ev / 4)) * level) / 100) + 5) * nature_modifier)
+        return stat
+
+    def calculate_hp_ev(self, total_hp: int, base_hp: int, iv: int, level: int = 100) -> int:
+        """
+        Calculate HP EV from total HP stat using the reverse of the Pokemon HP formula.
+        
+        If the target HP is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible HP value. For impossibly high HP values, returns 252 EVs.
+        For impossibly low HP values, returns 0 EVs.
+        
+        Args:
+            total_hp (int): Total HP stat value
+            base_hp (int): Base HP stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        if level <= 0:
+            raise ValueError("Level must be greater than 0")
+        
+        # Calculate the minimum and maximum possible HP values
+        min_hp = self.calculate_hp(base_hp, iv, 0, level)
+        max_hp = self.calculate_hp(base_hp, iv, 252, level)
+        
+        # If target HP is impossible, return the closest boundary
+        if total_hp <= min_hp:
+            return 0  # Return 0 EVs for impossibly low HP
+        elif total_hp >= max_hp:
+            return 252  # Return 252 EVs for impossibly high HP
+        
+        # Find the EV that gives us the closest HP value
+        best_ev = 0
+        best_diff = float('inf')
+        
+        for test_ev in range(0, 253, 4):  # EVs are always multiples of 4
+            test_hp = self.calculate_hp(base_hp, iv, test_ev, level)
+            diff = abs(test_hp - total_hp)
+            
+            if diff < best_diff:
+                best_diff = diff
+                best_ev = test_ev
+            elif diff == best_diff and test_ev < best_ev:
+                # If we have the same difference, prefer the lower EV
+                best_ev = test_ev
+        
+        return best_ev
+    
+    def calculate_other_stat_ev(self, total_stat: int, base_stat: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate EV for other stats (Attack, Defense, Sp. Attack, Sp. Defense, Speed) using the reverse of the Pokemon stat formula.
+        
+        If the target stat is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible stat value. For impossibly high stat values, returns 252 EVs.
+        For impossibly low stat values, returns 0 EVs.
+        
+        Args:
+            total_stat (int): Total stat value
+            base_stat (int): Base stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        if level <= 0:
+            raise ValueError("Level must be greater than 0")
+        if nature_modifier <= 0:
+            raise ValueError("Nature modifier must be greater than 0")
+        
+        # Calculate the minimum and maximum possible stat values
+        min_stat = self.calculate_other_stat(base_stat, iv, 0, level, nature_modifier)
+        max_stat = self.calculate_other_stat(base_stat, iv, 252, level, nature_modifier)
+        
+        # If target stat is impossible, return the closest boundary
+        if total_stat <= min_stat:
+            return 0  # Return 0 EVs for impossibly low stat
+        elif total_stat >= max_stat:
+            return 252  # Return 252 EVs for impossibly high stat
+        
+        # Find the EV that gives us the closest stat value
+        best_ev = 0
+        best_diff = float('inf')
+        
+        for test_ev in range(0, 253, 4):  # EVs are always multiples of 4
+            test_stat = self.calculate_other_stat(base_stat, iv, test_ev, level, nature_modifier)
+            diff = abs(test_stat - total_stat)
+            
+            if diff < best_diff:
+                best_diff = diff
+                best_ev = test_ev
+            elif diff == best_diff and test_ev < best_ev:
+                # If we have the same difference, prefer the lower EV
+                best_ev = test_ev
+        
+        return best_ev
+    
+    def calculate_attack_ev(self, total_attack: int, base_attack: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Attack EV from total Attack stat.
+        
+        If the target Attack is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Attack value. For impossibly high Attack values, returns 252 EVs.
+        For impossibly low Attack values, returns 0 EVs.
+        
+        Args:
+            total_attack (int): Total Attack stat value
+            base_attack (int): Base Attack stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        return self.calculate_other_stat_ev(total_attack, base_attack, iv, level, nature_modifier)
+    
+    def calculate_defense_ev(self, total_defense: int, base_defense: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Defense EV from total Defense stat.
+        
+        If the target Defense is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Defense value. For impossibly high Defense values, returns 252 EVs.
+        For impossibly low Defense values, returns 0 EVs.
+        
+        Args:
+            total_defense (int): Total Defense stat value
+            base_defense (int): Base Defense stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        return self.calculate_other_stat_ev(total_defense, base_defense, iv, level, nature_modifier)
+    
+    def calculate_special_attack_ev(self, total_special_attack: int, base_special_attack: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Special Attack EV from total Special Attack stat.
+        
+        If the target Special Attack is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Special Attack value. For impossibly high Special Attack values, returns 252 EVs.
+        For impossibly low Special Attack values, returns 0 EVs.
+        
+        Args:
+            total_special_attack (int): Total Special Attack stat value
+            base_special_attack (int): Base Special Attack stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        return self.calculate_other_stat_ev(total_special_attack, base_special_attack, iv, level, nature_modifier)
+    
+    def calculate_special_defense_ev(self, total_special_defense: int, base_special_defense: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Special Defense EV from total Special Defense stat.
+        
+        If the target Special Defense is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Special Defense value. For impossibly high Special Defense values, returns 252 EVs.
+        For impossibly low Special Defense values, returns 0 EVs.
+        
+        Args:
+            total_special_defense (int): Total Special Defense stat value
+            base_special_defense (int): Base Special Defense stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        return self.calculate_other_stat_ev(total_special_defense, base_special_defense, iv, level, nature_modifier)
+    
+    def calculate_speed_ev(self, total_speed: int, base_speed: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Speed EV from total Speed stat.
+        
+        If the target Speed is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Speed value. For impossibly high Speed values, returns 252 EVs.
+        For impossibly low Speed values, returns 0 EVs.
+        
+        Args:
+            total_speed (int): Total Speed stat value
+            base_speed (int): Base Speed stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        return self.calculate_other_stat_ev(total_speed, base_speed, iv, level, nature_modifier)
+
+    def calculate_hp_ev_from_species(self, species: str, total_hp: int, iv: int, level: int = 100) -> int:
+        """
+        Calculate HP EV from total HP stat using species name.
+        
+        If the target HP is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible HP value. For impossibly high HP values, returns 252 EVs.
+        For impossibly low HP values, returns 0 EVs.
+        
+        Args:
+            species (str): Pokemon species name
+            total_hp (int): Total HP stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_hp_ev(total_hp, base_stats.hp, iv, level)
+    
+    def calculate_attack_ev_from_species(self, species: str, total_attack: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Attack EV from total Attack stat using species name.
+        
+        If the target Attack is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Attack value. For impossibly high Attack values, returns 252 EVs.
+        For impossibly low Attack values, returns 0 EVs.
+        
+        Args:
+            species (str): Pokemon species name
+            total_attack (int): Total Attack stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_attack_ev(total_attack, base_stats.attack, iv, level, nature_modifier)
+    
+    def calculate_defense_ev_from_species(self, species: str, total_defense: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Defense EV from total Defense stat using species name.
+        
+        If the target Defense is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Defense value. For impossibly high Defense values, returns 252 EVs.
+        For impossibly low Defense values, returns 0 EVs.
+        
+        Args:
+            species (str): Pokemon species name
+            total_defense (int): Total Defense stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_defense_ev(total_defense, base_stats.defense, iv, level, nature_modifier)
+    
+    def calculate_special_attack_ev_from_species(self, species: str, total_special_attack: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Special Attack EV from total Special Attack stat using species name.
+        
+        If the target Special Attack is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Special Attack value. For impossibly high Special Attack values, returns 252 EVs.
+        For impossibly low Special Attack values, returns 0 EVs.
+        
+        Args:
+            species (str): Pokemon species name
+            total_special_attack (int): Total Special Attack stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_special_attack_ev(total_special_attack, base_stats.special_attack, iv, level, nature_modifier)
+    
+    def calculate_special_defense_ev_from_species(self, species: str, total_special_defense: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Special Defense EV from total Special Defense stat using species name.
+        
+        If the target Special Defense is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Special Defense value. For impossibly high Special Defense values, returns 252 EVs.
+        For impossibly low Special Defense values, returns 0 EVs.
+        
+        Args:
+            species (str): Pokemon species name
+            total_special_defense (int): Total Special Defense stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_special_defense_ev(total_special_defense, base_stats.special_defense, iv, level, nature_modifier)
+    
+    def calculate_speed_ev_from_species(self, species: str, total_speed: int, iv: int, level: int = 100, nature_modifier: float = 1.0) -> int:
+        """
+        Calculate Speed EV from total Speed stat using species name.
+        
+        If the target Speed is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible Speed value. For impossibly high Speed values, returns 252 EVs.
+        For impossibly low Speed values, returns 0 EVs.
+        
+        Args:
+            species (str): Pokemon species name
+            total_speed (int): Total Speed stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            int: Required EV value (0-252) - closest possible value if target is impossible
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_speed_ev(total_speed, base_stats.speed, iv, level, nature_modifier)
+    
+    def calculate_all_evs_from_species(self, species: str, stats: Dict[str, int], ivs: Dict[str, int], level: int = 100, nature_modifier: float = 1.0) -> Dict[str, int]:
+        """
+        Calculate all EV values for a Pokemon using species name and target stats.
+        
+        If any target stat is impossible to achieve with any EV value, returns the EV that
+        produces the closest possible stat value. For impossibly high stat values, returns 252 EVs.
+        For impossibly low stat values, returns 0 EVs.
+        
+        Args:
+            species (str): Pokemon species name
+            stats (Dict[str, int]): Dictionary of target stat values with keys: 'hp', 'attack', 'defense', 'special_attack', 'special_defense', 'speed'
+            ivs (Dict[str, int]): Dictionary of IV values with keys: 'hp', 'attack', 'defense', 'special_attack', 'special_defense', 'speed'
+            level (int): Pokemon level (1-100)
+            nature_modifier (float): Nature modifier (0.9 for hindering, 1.0 for neutral, 1.1 for beneficial)
+        
+        Returns:
+            Dict[str, int]: Dictionary of required EV values for each stat - closest possible values if targets are impossible
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        
+        evs = {}
+        
+        # Calculate HP EV (no nature modifier)
+        if 'hp' in stats:
+            evs['hp'] = self.calculate_hp_ev(stats['hp'], base_stats.hp, ivs.get('hp', 31), level)
+        
+        # Calculate other stat EVs (with nature modifier)
+        if 'attack' in stats:
+            evs['attack'] = self.calculate_attack_ev(stats['attack'], base_stats.attack, ivs.get('attack', 31), level, nature_modifier)
+        
+        if 'defense' in stats:
+            evs['defense'] = self.calculate_defense_ev(stats['defense'], base_stats.defense, ivs.get('defense', 31), level, nature_modifier)
+        
+        if 'special_attack' in stats:
+            evs['special_attack'] = self.calculate_special_attack_ev(stats['special_attack'], base_stats.special_attack, ivs.get('special_attack', 31), level, nature_modifier)
+        
+        if 'special_defense' in stats:
+            evs['special_defense'] = self.calculate_special_defense_ev(stats['special_defense'], base_stats.special_defense, ivs.get('special_defense', 31), level, nature_modifier)
+        
+        if 'speed' in stats:
+            evs['speed'] = self.calculate_speed_ev(stats['speed'], base_stats.speed, ivs.get('speed', 31), level, nature_modifier)
+        
+        return evs
+
+    def calculate_hp_ev_and_nature_combinations(self, total_hp: int, base_hp: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible EV and nature modifier combinations for HP.
+        Note: HP is not affected by nature, so this returns only the EV value with nature_modifier=1.0.
+        
+        Args:
+            total_hp (int): Total HP stat value
+            base_hp (int): Base HP stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        # HP is not affected by nature, so there's only one combination
+        ev = self.calculate_hp_ev(total_hp, base_hp, iv, level)
+        return [(ev, 1.0)]
+    
+    def calculate_other_stat_ev_and_nature_combinations(self, total_stat: int, base_stat: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible EV and nature modifier combinations for other stats.
+        
+        Args:
+            total_stat (int): Total stat value
+            base_stat (int): Base stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        if level <= 0:
+            raise ValueError("Level must be greater than 0")
+        
+        combinations = []
+        
+        # Try each nature modifier: hindering (0.9), neutral (1.0), beneficial (1.1)
+        nature_modifiers = [0.9, 1.0, 1.1]
+        
+        for nature_modifier in nature_modifiers:
+            try:
+                ev = self.calculate_other_stat_ev(total_stat, base_stat, iv, level, nature_modifier)
+                
+                # Verify this combination actually produces the target stat (or closest possible)
+                calculated_stat = self.calculate_other_stat(base_stat, iv, ev, level, nature_modifier)
+                
+                # Accept the combination if it produces the target stat or the closest possible value
+                if calculated_stat == total_stat or abs(calculated_stat - total_stat) <= 1:
+                    combinations.append((ev, nature_modifier))
+                    
+            except (ValueError, ZeroDivisionError):
+                # Skip invalid combinations
+                continue
+        
+        # Remove duplicates and sort by EV (ascending)
+        unique_combinations = list(set(combinations))
+        unique_combinations.sort(key=lambda x: x[0])
+        
+        return unique_combinations
+    
+    def calculate_attack_ev_and_nature_combinations(self, total_attack: int, base_attack: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Attack EV and nature modifier combinations.
+        
+        Args:
+            total_attack (int): Total Attack stat value
+            base_attack (int): Base Attack stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        return self.calculate_other_stat_ev_and_nature_combinations(total_attack, base_attack, iv, level)
     
-    
+    def calculate_defense_ev_and_nature_combinations(self, total_defense: int, base_defense: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Defense EV and nature modifier combinations.
+        
+        Args:
+            total_defense (int): Total Defense stat value
+            base_defense (int): Base Defense stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        return self.calculate_other_stat_ev_and_nature_combinations(total_defense, base_defense, iv, level)
+    
+    def calculate_special_attack_ev_and_nature_combinations(self, total_special_attack: int, base_special_attack: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Special Attack EV and nature modifier combinations.
+        
+        Args:
+            total_special_attack (int): Total Special Attack stat value
+            base_special_attack (int): Base Special Attack stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        return self.calculate_other_stat_ev_and_nature_combinations(total_special_attack, base_special_attack, iv, level)
+    
+    def calculate_special_defense_ev_and_nature_combinations(self, total_special_defense: int, base_special_defense: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Special Defense EV and nature modifier combinations.
+        
+        Args:
+            total_special_defense (int): Total Special Defense stat value
+            base_special_defense (int): Base Special Defense stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        return self.calculate_other_stat_ev_and_nature_combinations(total_special_defense, base_special_defense, iv, level)
+    
+    def calculate_speed_ev_and_nature_combinations(self, total_speed: int, base_speed: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Speed EV and nature modifier combinations.
+        
+        Args:
+            total_speed (int): Total Speed stat value
+            base_speed (int): Base Speed stat
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        return self.calculate_other_stat_ev_and_nature_combinations(total_speed, base_speed, iv, level)
+    
+    def calculate_hp_ev_and_nature_combinations_from_species(self, species: str, total_hp: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible HP EV and nature modifier combinations using species name.
+        
+        Args:
+            species (str): Pokemon species name
+            total_hp (int): Total HP stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_hp_ev_and_nature_combinations(total_hp, base_stats.hp, iv, level)
+    
+    def calculate_attack_ev_and_nature_combinations_from_species(self, species: str, total_attack: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Attack EV and nature modifier combinations using species name.
+        
+        Args:
+            species (str): Pokemon species name
+            total_attack (int): Total Attack stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_attack_ev_and_nature_combinations(total_attack, base_stats.attack, iv, level)
+    
+    def calculate_defense_ev_and_nature_combinations_from_species(self, species: str, total_defense: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Defense EV and nature modifier combinations using species name.
+        
+        Args:
+            species (str): Pokemon species name
+            total_defense (int): Total Defense stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_defense_ev_and_nature_combinations(total_defense, base_stats.defense, iv, level)
+    
+    def calculate_special_attack_ev_and_nature_combinations_from_species(self, species: str, total_special_attack: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Special Attack EV and nature modifier combinations using species name.
+        
+        Args:
+            species (str): Pokemon species name
+            total_special_attack (int): Total Special Attack stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_special_attack_ev_and_nature_combinations(total_special_attack, base_stats.special_attack, iv, level)
+    
+    def calculate_special_defense_ev_and_nature_combinations_from_species(self, species: str, total_special_defense: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Special Defense EV and nature modifier combinations using species name.
+        
+        Args:
+            species (str): Pokemon species name
+            total_special_defense (int): Total Special Defense stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_special_defense_ev_and_nature_combinations(total_special_defense, base_stats.special_defense, iv, level)
+    
+    def calculate_speed_ev_and_nature_combinations_from_species(self, species: str, total_speed: int, iv: int, level: int = 100) -> List[Tuple[int, float]]:
+        """
+        Calculate all possible Speed EV and nature modifier combinations using species name.
+        
+        Args:
+            species (str): Pokemon species name
+            total_speed (int): Total Speed stat value
+            iv (int): Individual Value (0-31)
+            level (int): Pokemon level (1-100)
+        
+        Returns:
+            List[Tuple[int, float]]: List of (EV, nature_modifier) combinations
+        """
+        base_stats = self.get_base_stats_from_species(species)
+        return self.calculate_speed_ev_and_nature_combinations(total_speed, base_stats.speed, iv, level)

localdex-0.2.45.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: localdex
+Version: 0.2.45
+Summary: A local Pokemon data repository/Pokedex with fast offline access
+Author-email: LocalDex Team <localdex@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/colefoster/localdex
+Project-URL: Documentation, https://localdex.readthedocs.io/
+Project-URL: Repository, https://github.com/colefoster/localdex
+Project-URL: Bug Tracker, https://github.com/colefoster/localdex/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: typing-extensions
+Provides-Extra: core
+Provides-Extra: gen1
+Provides-Extra: gen2
+Provides-Extra: gen3
+Provides-Extra: gen4
+Provides-Extra: gen5
+Provides-Extra: gen6
+Provides-Extra: gen7
+Provides-Extra: gen8
+Provides-Extra: gen9
+Provides-Extra: learnsets
+Provides-Extra: items
+Provides-Extra: abilities
+Provides-Extra: full
+Requires-Dist: localdex[abilities,gen1,gen2,gen3,gen4,gen5,gen6,gen7,gen8,gen9,items,learnsets]; extra == "full"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+# LocalDex
+
+A fast, offline-first Python library for Pokemon data access. LocalDex provides comprehensive Pokemon information without requiring network requests.
+
+[![PyPI version](https://badge.fury.io/py/localdex.svg)](https://badge.fury.io/py/localdex)
+[![Python versions](https://img.shields.io/pypi/pyversions/localdex.svg)](https://pypi.org/project/localdex/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **Offline Access**: All data stored locally - no network requests required
+- **Fast Lookups**: Optimized caching and search capabilities
+- **Comprehensive Data**: Pokemon, moves, abilities, and items
+- **CLI Interface**: Command-line access to all data
+- **Type Hints**: Full type support for better development experience
+- **Stat Calculations**: Built-in stat calculation methods
+
+## Installation
+
+```bash
+pip install localdex
+```
+
+## Quick Start
+
+```python
+from localdex import LocalDex
+
+# Initialize the dex
+dex = LocalDex()
+
+# Get Pokemon by name or ID
+pikachu = dex.get_pokemon("pikachu")
+charizard = dex.get_pokemon_by_id(6)
+
+# Get moves and abilities
+thunderbolt = dex.get_move("thunderbolt")
+lightning_rod = dex.get_ability("lightning-rod")
+
+# Search Pokemon
+fire_types = dex.search_pokemon(type="fire")
+fast_pokemon = dex.search_pokemon(min_speed=120)
+legendary_fire = dex.search_pokemon(type="fire", is_legendary=True)
+
+# Get all data
+all_pokemon = dex.get_all_pokemon()
+all_moves = dex.get_all_moves()
+```
+
+## CLI Usage
+
+```bash
+# Get Pokemon information
+localdex pokemon pikachu
+localdex pokemon 25
+
+# Search Pokemon
+localdex search --type Fire --generation 1
+localdex search --legendary --min-attack 100
+
+# Get move and ability info
+localdex move thunderbolt
+localdex ability lightningrod
+
+# List data
+localdex list-pokemon --generation 1
+localdex list-moves --type Electric
+
+# Export data
+localdex export --format json --output pokemon_data.json
+
+# Run demo
+localdex demo
+```
+
+## API Reference
+
+### Core Methods
+
+- `get_pokemon(name_or_id)` - Get Pokemon by name or ID
+- `get_pokemon_by_id(id)` - Get Pokemon by ID
+- `get_pokemon_by_name(name)` - Get Pokemon by name
+- `get_move(name)` - Get move by name
+- `get_ability(name)` - Get ability by name
+- `get_item(name)` - Get item by name
+- `search_pokemon(**filters)` - Search Pokemon with filters
+- `get_all_pokemon()` - Get all Pokemon
+- `get_all_moves()` - Get all moves
+- `get_all_abilities()` - Get all abilities
+- `get_all_items()` - Get all items
+
+### Search Filters
+
+```python
+# Available filters for search_pokemon()
+dex.search_pokemon(
+    type="Fire",              # Pokemon type
+    generation=1,             # Generation number
+    is_legendary=True,        # Legendary Pokemon
+    is_mythical=True,         # Mythical Pokemon
+    min_attack=100,           # Minimum attack stat
+    max_speed=50,             # Maximum speed stat
+    name_contains="char"      # Name contains text
+)
+```
+
+### Data Models
+
+```python
+# Pokemon model
+pokemon = dex.get_pokemon("pikachu")
+print(f"{pokemon.name} - {pokemon.types}")
+print(f"HP: {pokemon.base_stats.hp}")
+print(f"Attack: {pokemon.base_stats.attack}")
+
+# Move model
+move = dex.get_move("thunderbolt")
+print(f"{move.name} - Power: {move.base_power}, Type: {move.type}")
+
+# Ability model
+ability = dex.get_ability("lightning-rod")
+print(f"{ability.name} - {ability.description}")
+```
+
+## Stat Calculations
+
+LocalDex includes methods for calculating Pokemon stats:
+
+```python
+# Calculate stats with IVs, EVs, and level
+hp = dex.get_hp_stat_from_species("pikachu", iv=31, ev=252, level=100)
+attack = dex.get_attack_stat_from_species("pikachu", iv=31, ev=252, level=100)
+
+# Generic stat calculation
+hp = dex.calculate_hp(base=35, iv=31, ev=252, level=100)
+attack = dex.calculate_other_stat(base=55, iv=31, ev=252, level=100, nature_modifier=1.1)
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Data Sources
+
+Data sourced from [Pokemon Showdown](https://github.com/smogon/pokemon-showdown) and [PokeAPI](https://pokeapi.co/).
+
+

{localdex-0.2.40.dist-info → localdex-0.2.45.dist-info}/RECORD

@@ -1,6 +1,6 @@
 localdex/__init__.py,sha256=TTeh9Eys8nLtcw7Dg2equDqnouthIUyfsqvABtzR2vA,403
 localdex/cli.py,sha256=WqBCyA0akAFJNrYa8jCA3zoZgYEptDYDMGfAGkvKyZc,19317
-localdex/core.py,sha256=0kjuL388OniX7hRG6c5fT72nCC76LolpAB2UFrNXPns,20480
+localdex/core.py,sha256=fXalY6GyZ94QhD_M0KW_l9tdhq-bb785O14sMmvzenI,54495
 localdex/data_loader.py,sha256=hi9aSTto5Ti-OBGOgrQ-XwD5hmivsUwS1uC4rulhwQI,11366
 localdex/download_data.py,sha256=T4A3OliGe2RsrRV1glyCqRcFhQIRt29KcY1K1-IqTuU,21597
 localdex/exceptions.py,sha256=Z02-8Kci6jFDk2nnGdVSHZJMDDWE9vuwuASs4VM3To8,2777
@@ -4826,8 +4826,9 @@ localdex/models/ability.py,sha256=AQzv3XUHHl4sustMJjPDDjJOjXu2GMLTfcM3-tqQ_1w,30
 localdex/models/item.py,sha256=zXao8F-jBPUGq_YLeGeYeK_dZVI7aZMXtWOPwR3qusY,4677
 localdex/models/move.py,sha256=hfgcWI4ziz5MMvc9ddmkotxzYYdrSUqZZQ72IU5tucs,7629
 localdex/models/pokemon.py,sha256=glnOiEhkFc25U54hJHwUkT-okUgtL2prg3269YXI3w0,5422
-localdex-0.2.40.dist-info/METADATA,sha256=RKqrxFuWY0y4-TZzkMJcIja370hWETfwnzWM1w6TpAA,8016
-localdex-0.2.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-localdex-0.2.40.dist-info/entry_points.txt,sha256=n5GxSeQo-MRuvrT2wVk7hOzEFFsWf6tkBjkzmGIYJe4,47
-localdex-0.2.40.dist-info/top_level.txt,sha256=vtupDMH-IaxVCoEZrmE0QzdTwhaKzngVJbTA1NkR_MY,9
-localdex-0.2.40.dist-info/RECORD,,
+localdex-0.2.45.dist-info/licenses/LICENSE,sha256=i6DyIs1YqXBAxAIiGBS6vp2iQP9tiMd47S8dvaeFmDQ,1065
+localdex-0.2.45.dist-info/METADATA,sha256=lbBlCaUAPBxN35SyxWC_Z9sIk-ScqhQEtGwT4JRJGOI,5886
+localdex-0.2.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+localdex-0.2.45.dist-info/entry_points.txt,sha256=n5GxSeQo-MRuvrT2wVk7hOzEFFsWf6tkBjkzmGIYJe4,47
+localdex-0.2.45.dist-info/top_level.txt,sha256=vtupDMH-IaxVCoEZrmE0QzdTwhaKzngVJbTA1NkR_MY,9
+localdex-0.2.45.dist-info/RECORD,,

localdex-0.2.45.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 LocalDex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

localdex-0.2.40.dist-info/METADATA

@@ -1,270 +0,0 @@
-Metadata-Version: 2.4
-Name: localdex
-Version: 0.2.40
-Summary: A local Pokemon data repository/Pokedex with fast offline access
-Author-email: LocalDex Team <localdex@example.com>
-License: MIT
-Project-URL: Homepage, https://github.com/colefoster/localdex
-Project-URL: Documentation, https://localdex.readthedocs.io/
-Project-URL: Repository, https://github.com/colefoster/localdex
-Project-URL: Bug Tracker, https://github.com/colefoster/localdex/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Games/Entertainment
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: requests
-Requires-Dist: typing-extensions
-Provides-Extra: core
-Provides-Extra: gen1
-Provides-Extra: gen2
-Provides-Extra: gen3
-Provides-Extra: gen4
-Provides-Extra: gen5
-Provides-Extra: gen6
-Provides-Extra: gen7
-Provides-Extra: gen8
-Provides-Extra: gen9
-Provides-Extra: learnsets
-Provides-Extra: items
-Provides-Extra: abilities
-Provides-Extra: full
-Requires-Dist: localdex[abilities,gen1,gen2,gen3,gen4,gen5,gen6,gen7,gen8,gen9,items,learnsets]; extra == "full"
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: black>=22.0.0; extra == "dev"
-Requires-Dist: isort>=5.0.0; extra == "dev"
-Requires-Dist: mypy>=1.0.0; extra == "dev"
-Requires-Dist: flake8>=5.0.0; extra == "dev"
-
-# LocalDex
-
-A fast, offline-first Python library for Pokemon data access. LocalDex provides comprehensive Pokemon information without requiring network requests, making it perfect for applications that need reliable, fast access to Pokemon data.
-
-[![PyPI version](https://badge.fury.io/py/localdex.svg)](https://badge.fury.io/py/localdex)
-[![Python versions](https://img.shields.io/pypi/pyversions/localdex.svg)](https://pypi.org/project/localdex/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Tests](https://github.com/colefoster/localdex/actions/workflows/release.yml/badge.svg)](https://github.com/colefoster/localdex/actions/workflows/release.yml)
-
-## Features
-
-- **100% Offline**: All data is stored locally - no network requests required
-- **Fast Access**: Optimized for quick lookups and searches
-- **Comprehensive Data**: Pokemon, moves, abilities, items, and more
-- **Flexible Installation**: Choose which data sets to include
-- **Type Hints**: Full type support for better development experience
-- **Multiple Generations**: Support for all Pokemon generations
-- **Competitive Data**: Includes battle sets and competitive information
-
-## Installation
-
-### Basic Installation
-
-```bash
-pip install localdex
-```
-
-### Selective Data Installation
-
-Install only the data you need to minimize package size:
-
-```bash
-# Core Pokemon data only
-pip install localdex[core]
-
-# Specific generation
-pip install localdex[gen1]  # Generation 1 only
-pip install localdex[gen9]  # Generation 9 only
-
-# Additional data sets
-pip install localdex[competitive]  # Competitive battle data
-pip install localdex[learnsets]    # Detailed move learnsets
-pip install localdex[items]        # Item data
-pip install localdex[abilities]    # Ability data
-
-# Full installation with everything
-pip install localdex[full]
-```
-
-
-## Quick Start
-
-```python
-from localdex import LocalDex
-
-# Initialize the dex
-dex = LocalDex()
-
-# Get Pokemon by name
-pikachu = dex.get_pokemon("pikachu")
-print(f"{pikachu.name} - {pikachu.types}")
-
-# Get Pokemon by ID
-charizard = dex.get_pokemon_by_id(6)
-print(f"{charizard.name} - HP: {charizard.base_stats.hp}")
-
-# Get Pokemon stats
-bulbasaur = dex.get_pokemon("bulbasaur")
-print(f"{bulbasaur.name} - Attack: {bulbasaur.base_stats.attack}, Speed: {bulbasaur.base_stats.speed}")
-
-# Get moves
-thunderbolt = dex.get_move("thunderbolt")
-print(f"{thunderbolt.name} - Power: {thunderbolt.base_power}, Type: {thunderbolt.type}")
-
-# Get abilities (note: use dashes in names like "lightning-rod")
-lightning_rod = dex.get_ability("lightning-rod")
-print(f"{lightning_rod.name} - {lightning_rod.description}")
-
-# Search Pokemon by type (case-insensitive)
-fire_types = dex.search_pokemon(type="fire")
-print(f"Fire type Pokemon: {[p.name for p in fire_types[:5]]}")
-
-# Search Pokemon by stat
-fast_pokemon = dex.search_pokemon(min_speed=120)
-print(f"Very fast Pokemon: {[p.name for p in fast_pokemon[:5]]}")
-
-# Get all moves of a specific type (case-insensitive)
-all_moves = dex.get_all_moves()
-electric_moves = [m for m in all_moves if m.type.lower() == "electric"]
-print(f"Electric moves count: {len(electric_moves)}")
-print(f"First 5 Electric moves: {[m.name for m in electric_moves[:5]]}")
-
-## API Reference
-
-### LocalDex Class
-
-The main class for accessing Pokemon data.
-
-#### Methods
-
-- `get_pokemon(name_or_id: Union[str, int]) -> Pokemon`: Get Pokemon by name or ID
-- `get_pokemon_by_id(id: int) -> Pokemon`: Get Pokemon by ID
-- `get_pokemon_by_name(name: str) -> Pokemon`: Get Pokemon by name
-- `search_pokemon(**filters) -> List[Pokemon]`: Search Pokemon with filters
-- `get_move(name: str) -> Move`: Get move by name
-- `get_ability(name: str) -> Ability`: Get ability by name
-- `get_item(name: str) -> Item`: Get item by name
-- `get_all_pokemon() -> List[Pokemon]`: Get all Pokemon
-- `get_all_moves() -> List[Move]`: Get all moves
-- `get_all_abilities() -> List[Ability]`: Get all abilities
-- `get_all_items() -> List[Item]`: Get all items
-
-#### Search Filters
-
-```python
-# Search by type
-fire_pokemon = dex.search_pokemon(type="Fire")
-
-# Search by generation
-gen1_pokemon = dex.search_pokemon(generation=1)
-
-# Search by multiple criteria
-legendary_fire = dex.search_pokemon(type="Fire", is_legendary=True)
-
-# Search by base stat range
-strong_pokemon = dex.search_pokemon(min_attack=100)
-```
-
-### Data Models
-
-#### Pokemon
-
-```python
-class Pokemon:
-    id: int
-    name: str
-    types: List[str]
-    base_stats: BaseStats
-    abilities: Dict[str, Ability]
-    moves: List[Move]
-    height: float
-    weight: float
-    description: str
-    # ... and more
-```
-
-#### Move
-
-```python
-class Move:
-    name: str
-    type: str
-    category: str
-    base_power: int
-    accuracy: int
-    pp: int
-    description: str
-    # ... and more
-```
-
-#### Ability
-
-```python
-class Ability:
-    name: str
-    description: str
-    short_description: str
-    # ... and more
-```
-
-## Data Sets
-
-LocalDex organizes data into logical sets that can be installed independently:
-
-### Core Data (`core`)
-- Basic Pokemon information (name, types, base stats)
-- Essential for most applications
-
-### Generation Data (`gen1`-`gen9`)
-- Pokemon data for specific generations
-- Useful for generation-specific applications
-
-### Additional Data Sets
-- **Competitive** (`competitive`): Battle sets and competitive data
-- **Learnsets** (`learnsets`): Detailed move learning information
-- **Items** (`items`): Item data and effects
-- **Abilities** (`abilities`): Detailed ability information
-
-## CLI Usage
-
-LocalDex includes a command-line interface for quick data access:
-
-```bash
-# Get Pokemon information
-localdex pokemon pikachu
-
-# Search Pokemon
-localdex search --type Fire --generation 1
-
-# Get move information
-localdex move thunderbolt
-
-# Get ability information
-localdex ability lightningrod
-
-# List all Pokemon
-localdex list-pokemon
-
-# Export data to JSON
-localdex export --format json --output pokemon_data.json
-```
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## Data Sources
-
-LocalDex uses data from:
-- [Pokemon Showdown](https://github.com/smogon/pokemon-showdown)
-- [PokeAPI](https://pokeapi.co/) (for initial data collection)
-
-