dvitel/hearthstone huggingface dataset:
Card: Equality NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END Change the Health of ALL minions to 1.

Python implementation:
class Equality(SpellCard):§    def __init__(self):§        super().__init__("Equality", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§§        targets = copy.copy(game.other_player.minions)§        targets.extend(player.minions)§§        for minion in targets:§            minion.set_health_to(1)§§    def can_use(self, player, game):§        return super().can_use(player, game) and (len(player.minions) > 0 or len(game.other_player.minions) > 0)§
Card: Ethereal Arcanist NAME_END 3 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END NIL RACE_END Rare RARITY_END If you control a <b>Secret</b> at the end of your turn, gain +2/+2.

Python implementation:
class EtherealArcanist(MinionCard):§    def __init__(self):§        super().__init__("Ethereal Arcanist", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(3, 3, effects=[Effect(TurnEnded(HasSecret()), ActionTag(Give(ChangeAttack(2)), SelfSelector())), Effect(TurnEnded(HasSecret()), ActionTag(Give(ChangeHealth(2)), SelfSelector()))])§
Card: Eviscerate NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $2 damage. <b>Combo:</b> Deal $4 damage instead.

Python implementation:
class Eviscerate(SpellCard):§    def __init__(self):§        super().__init__("Eviscerate", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        if player.cards_played > 0:§            self.target.damage(player.effective_spell_damage(4), self)§        else:§            self.target.damage(player.effective_spell_damage(2), self)§
Card: Explosive Shot NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $5 damage to a minion and $2 damage to adjacent ones.

Python implementation:
class ExplosiveShot(SpellCard):§    def __init__(self):§        super().__init__("Explosive Shot", 5, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        index = self.target.index§        if self.target.index < len(self.target.player.minions) - 1:§            minion = self.target.player.minions[index + 1]§            minion.damage(player.effective_spell_damage(2), self)§§        self.target.damage(player.effective_spell_damage(5), self)§§        if self.target.index > 0:§            minion = self.target.player.minions[index - 1]§            minion.damage(player.effective_spell_damage(2), self)§
Card: Faceless Manipulator NAME_END 3 ATK_END 3 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Choose a minion and become a copy of it.

Python implementation:
class FacelessManipulator(MinionCard):§    def __init__(self):§        super().__init__("Faceless Manipulator", 5, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=Battlecry(Replace(), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Faerie Dragon NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Common RARITY_END Can't be targeted by spells or Hero Powers.

Python implementation:
class FaerieDragon(MinionCard):§    def __init__(self):§        super().__init__("Faerie Dragon", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        return Minion(3, 2, spell_targetable=False)§
Card: Far Sight NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Epic RARITY_END Draw a card. That card costs (3) less.

Python implementation:
class FarSight(SpellCard):§    def __init__(self):§        super().__init__("Far Sight", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.EPIC)§§    def use(self, player, game):§        def reduce_cost(card):§            card.add_buff(Buff(ManaChange(-3)))§§        super().use(player, game)§        player.bind_once("card_drawn", reduce_cost)§        player.draw()§
Card: Felguard NAME_END 3 ATK_END 5 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Rare RARITY_END <b>Taunt</b>. <b>Battlecry:</b> Destroy one of your Mana Crystals.

Python implementation:
class Felguard(MinionCard):§    def __init__(self):§        super().__init__("Felguard", 3, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, minion_type=MINION_TYPE.DEMON, battlecry=Battlecry(DestroyManaCrystal(), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(3, 5, taunt=True)§
Card: Fen Creeper NAME_END 3 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Taunt</b>

Python implementation:
class FenCreeper(MinionCard):§    def __init__(self):§        super().__init__("Fen Creeper", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 6, taunt=True)§
Card: Feral Spirit NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Rare RARITY_END Summon two 2/3 Spirit Wolves with <b>Taunt</b>. <b>Overload:</b> (2)

Python implementation:
class FeralSpirit(SpellCard):§    def __init__(self):§        super().__init__("Feral Spirit", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, overload=2)§§    def use(self, player, game):§        super().use(player, game)§§        for i in range(0, 2):§            spirit_wolf = hearthbreaker.cards.minions.shaman.SpiritWolf()§            spirit_wolf.summon(player, game, len(player.minions))§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(player.minions) < 7§
Card: Finkle Einhorn NAME_END 3 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Python implementation:
class FinkleEinhorn(MinionCard):§    def __init__(self):§        super().__init__("Finkle Einhorn", 2, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, False)§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Flame Imp NAME_END 3 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Common RARITY_END <b>Battlecry:</b> Deal 3 damage to your hero.

Python implementation:
class FlameImp(MinionCard):§    def __init__(self):§        super().__init__("Flame Imp", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DEMON, battlecry=Battlecry(Damage(3), HeroSelector()))§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Flesheating Ghoul NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever a minion dies, gain +1 Attack.

Python implementation:
class FlesheatingGhoul(MinionCard):§    def __init__(self):§        super().__init__("Flesheating Ghoul", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(MinionDied(player=BothPlayer()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§
Card: Force of Nature NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END Summon three 2/2 Treants with <b>Charge</b> that die at the end of the turn.

Python implementation:
class ForceOfNature(SpellCard):§    def __init__(self):§        super().__init__("Force of Nature", 6, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§        from hearthbreaker.cards.minions.druid import ChargeTreant§        for i in [0, 1, 2]:§            treant_card = ChargeTreant()§            treant_card.summon(player, game, len(player.minions))§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(player.minions) < 7§
Card: Forked Lightning NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $2 damage to 2 random enemy minions. <b>Overload:</b> (2)

Python implementation:
class ForkedLightning(SpellCard):§    def __init__(self):§        super().__init__("Forked Lightning", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, overload=2)§§    def use(self, player, game):§        super().use(player, game)§§        minions = copy.copy(game.other_player.minions)§        for i in range(0, 2):§            minion = game.random_choice(minions)§            minions.remove(minion)§            minion.damage(player.effective_spell_damage(3), self)§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) >= 2§
Card: Freezing Trap NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Secret:</b> When an enemy minion attacks, return it to its owner's hand and it costs (2) more.

Python implementation:
class FreezingTrap(SecretCard):§    def __init__(self):§        super().__init__("Freezing Trap", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON)§§    def activate(self, player):§        player.game.current_player.bind("character_attack", self._reveal)§§    def deactivate(self, player):§        player.game.current_player.unbind("character_attack", self._reveal)§§    def _reveal(self, attacker, target):§        if isinstance(attacker, Minion) and not attacker.removed:§            attacker.bounce()§            attacker.card.add_buff(Buff(ManaChange(2)))§            super().reveal()§
Card: Frost Elemental NAME_END 5 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> <b>Freeze</b> a character.

Python implementation:
class FrostElemental(MinionCard):§    def __init__(self):§        super().__init__("Frost Elemental", 6, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Give(Frozen()), CharacterSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: Frothing Berserker NAME_END 2 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever a minion takes damage, gain +1 Attack.

Python implementation:
class FrothingBerserker(MinionCard):§    def __init__(self):§        super().__init__("Frothing Berserker", 3, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(2, 4, effects=[Effect(CharacterDamaged(player=BothPlayer(), condition=IsMinion()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§
Card: Gadgetzan Auctioneer NAME_END 4 ATK_END 4 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever you cast a spell, draw a card.

Python implementation:
class GadgetzanAuctioneer(MinionCard):§    def __init__(self):§        super().__init__("Gadgetzan Auctioneer", 6, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(4, 4, effects=[Effect(SpellCast(), ActionTag(Draw(), PlayerSelector()))])§
Card: Gladiator's Longbow NAME_END 5 ATK_END -1 DEF_END 7 COST_END 2 DUR_END Weapon TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Epic RARITY_END Your hero is <b>Immune</b> while attacking.

Python implementation:
class GladiatorsLongbow(WeaponCard):§    def __init__(self):§        super().__init__("Gladiator's Longbow", 7, CHARACTER_CLASS.HUNTER, CARD_RARITY.EPIC)§§    def create_weapon(self, player):§        return Weapon(5, 2, effects=[Effect(CharacterAttack(IsHero()), ActionTag(Give(BuffUntil(Immune(), AttackCompleted())), HeroSelector()))])§
Card: Grommash Hellscream NAME_END 4 ATK_END 9 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Charge</b> NL <b>Enrage:</b> +6 Attack

Python implementation:
class GrommashHellscream(MinionCard):§    def __init__(self):§        super().__init__("Grommash Hellscream", 8, CHARACTER_CLASS.WARRIOR, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(4, 9, charge=True, enrage=[Aura(ChangeAttack(6), SelfSelector())])§
Card: Gruul NAME_END 7 ATK_END 7 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END At the end of each turn, gain +1/+1 .

Python implementation:
class Gruul(MinionCard):§    def __init__(self):§        super().__init__("Gruul", 8, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 7, effects=[Effect(TurnEnded(player=BothPlayer()), ActionTag(Give([Buff(ChangeAttack(1)), Buff(ChangeHealth(1))]), SelfSelector()))])§
Card: Harrison Jones NAME_END 5 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Battlecry:</b> Destroy your opponent's weapon and draw cards equal to its Durability.

Python implementation:
class HarrisonJones(MinionCard):§    def __init__(self):§        super().__init__("Harrison Jones", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, battlecry=(Battlecry(Draw(Attribute("durability", WeaponSelector(EnemyPlayer()))), PlayerSelector()), Battlecry(Destroy(), WeaponSelector(EnemyPlayer()))))§§    def create_minion(self, player):§        return Minion(5, 4)§
Card: Harvest Golem NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Deathrattle:</b> Summon a 2/1 Damaged Golem.

Python implementation:
class HarvestGolem(MinionCard):§    def __init__(self):§        super().__init__("Harvest Golem", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 3, deathrattle=Deathrattle(Summon(DamagedGolem()), PlayerSelector()))§
Card: Headcrack NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $2 damage to the enemy hero. <b>Combo:</b> Return this to your hand next turn.

Python implementation:
class Headcrack(SpellCard):§    def __init__(self):§        super().__init__("Headcrack", 3, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        game.other_player.hero.damage(player.effective_spell_damage(2), self)§        if player.cards_played > 0:§            player.add_effect(Effect(TurnEnded(), ActionTag(AddCard(self), PlayerSelector())))§
Card: Heavy Axe NAME_END 1 ATK_END -1 DEF_END 1 COST_END 3 DUR_END Weapon TYPE_END Warrior PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class HeavyAxe(WeaponCard):§    def __init__(self):§        super().__init__("Heavy Axe", 1, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, False)§§    def create_weapon(self, player):§        return Weapon(1, 3)§
Card: Hogger NAME_END 4 ATK_END 4 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END At the end of your turn, summon a 2/2 Gnoll with <b>Taunt</b>.

Python implementation:
class Hogger(MinionCard):§    def __init__(self):§        super().__init__("Hogger", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(4, 4, effects=[Effect(TurnEnded(), ActionTag(Summon(Gnoll()), PlayerSelector()))])§
Card: Holy Fire NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $5 damage. Restore #5 Health to your hero.

Python implementation:
class HolyFire(SpellCard):§    def __init__(self):§        super().__init__("Holy Fire", 6, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.damage(player.effective_spell_damage(5), self)§        player.hero.heal(player.effective_heal_power(5), self)§
Card: Hungry Crab NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Epic RARITY_END <b>Battlecry:</b> Destroy a Murloc and gain +2/+2.

Python implementation:
class HungryCrab(MinionCard):§    def __init__(self):§        super().__init__("Hungry Crab", 1, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, minion_type=MINION_TYPE.BEAST, battlecry=(Battlecry(Kill(), MinionSelector(IsType(MINION_TYPE.MURLOC), BothPlayer())), Battlecry(Give([Buff(ChangeAttack(2)), Buff(ChangeHealth(2))]), SelfSelector())))§§    def create_minion(self, player):§        return Minion(1, 2)§
Card: Hyena NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Rare RARITY_END NIL

Python implementation:
class Hyena(MinionCard):§    def __init__(self):§        super().__init__("Hyena", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, False, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Ice Barrier NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Secret:</b> When your hero is attacked, gain 8 Armor.

Python implementation:
class IceBarrier(SecretCard):§    def __init__(self):§        super().__init__("Ice Barrier", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON)§§    def _reveal(self, attacker, target):§        if target is self.player.hero and not attacker.removed:§            attacker.player.game.other_player.hero.armor += 8§            super().reveal()§§    def activate(self, player):§        player.opponent.bind("character_attack", self._reveal)§§    def deactivate(self, player):§        player.opponent.unbind("character_attack", self._reveal)§
Card: Ice Block NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Secret:</b> When your hero takes fatal damage, prevent it and become <b>Immune</b> this turn.

Python implementation:
class IceBlock(SecretCard):§    def __init__(self):§        super().__init__("Ice Block", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.EPIC)§        self.player = None§§    def _reveal(self, character, attacker, amount):§        if character.is_hero():§            if character.health - amount <= 0:§                character.add_buff(BuffUntil(Immune(), TurnEnded(player=CurrentPlayer())))§                super().reveal()§§    def activate(self, player):§        player.bind("pre_damage", self._reveal)§§    def deactivate(self, player):§        player.unbind("pre_damage", self._reveal)§
Card: Ice Lance NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Freeze</b> a character. If it was already <b>Frozen</b>, deal $4 damage instead.

Python implementation:
class IceLance(SpellCard):§    def __init__(self):§        super().__init__("Ice Lance", 1, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        if self.target.frozen:§            self.target.damage(4, self)§        else:§            self.target.add_buff(Buff(Frozen()))§
Card: Illidan Stormrage NAME_END 7 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Demon RACE_END Legendary RARITY_END Whenever you play a card, summon a 2/1 Flame of Azzinoth.

Python implementation:
class IllidanStormrage(MinionCard):§    def __init__(self):§        super().__init__("Illidan Stormrage", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(7, 5, effects=[Effect(CardPlayed(), ActionTag(Summon(FlameOfAzzinoth()), PlayerSelector()))])§
Card: Imp NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Demon RACE_END Rare RARITY_END NIL

Python implementation:
class Imp(MinionCard):§    def __init__(self):§        super().__init__("Imp", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, False, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Imp Master NAME_END 1 ATK_END 5 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END At the end of your turn, deal 1 damage to this minion and summon a 1/1 Imp.

Python implementation:
class ImpMaster(MinionCard):§    def __init__(self):§        super().__init__("Imp Master", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(1, 5, effects=[Effect(TurnEnded(), ActionTag(Damage(1), SelfSelector())), Effect(TurnEnded(), ActionTag(Summon(Imp()), PlayerSelector()))])§
Card: Inner Fire NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END Change a minion's Attack to be equal to its Health.

Python implementation:
class InnerFire(SpellCard):§    def __init__(self):§        super().__init__("Inner Fire", 1, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        delta = self.target.health - self.target.calculate_attack()§        self.target.change_attack(delta)§
Card: Inner Rage NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $1 damage to a minion and give it +2 Attack.

Python implementation:
class InnerRage(SpellCard):§    def __init__(self):§        super().__init__("Inner Rage", 0, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(1, self)§        self.target.change_attack(2)§
Card: Ironbeak Owl NAME_END 2 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Battlecry:</b> <b>Silence</b> a minion.

Python implementation:
class IronbeakOwl(MinionCard):§    def __init__(self):§        super().__init__("Ironbeak Owl", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST, battlecry=Battlecry(Silence(), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 1)§
Card: Jungle Panther NAME_END 4 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Stealth</b>

Python implementation:
class JunglePanther(MinionCard):§    def __init__(self):§        super().__init__("Jungle Panther", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(4, 2, stealth=True)§
Card: Keeper of the Grove NAME_END 2 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Choose One</b> - Deal 2 damage; or <b>Silence</b> a minion.

Python implementation:
class KeeperOfTheGrove(MinionCard):§    def __init__(self):§        super().__init__("Keeper of the Grove", 4, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE, choices=[§            Choice(Moonfire(), Damage(2), CharacterSelector(players=BothPlayer(), picker=UserPicker())),§            Choice(Dispel(), Silence(), MinionSelector(players=BothPlayer(), picker=UserPicker()))§        ])§§    def create_minion(self, player):§        return Minion(2, 4)§