dvitel/hearthstone huggingface dataset:
Card: Reincarnate NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Destroy a minion, then return it to life with full Health.

Python implementation:
class Reincarnate(SpellCard):§§    def __init__(self):§        super().__init__("Reincarnate", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.die(self)§        game.check_delayed()§        self.target.card.summon(self.target.player, game, len(self.target.player.minions))§
Card: Shade of Naxxramas NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Stealth.</b> At the start of your turn, gain +1/+1.

Python implementation:
class ShadeOfNaxxramas(MinionCard):§    def __init__(self):§        super().__init__("Shade of Naxxramas", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(2, 2, stealth=True, effects=[Effect(TurnStarted(), ActionTag(Give([Buff(ChangeAttack(1)), Buff(ChangeHealth(1))]), SelfSelector()))])§
Card: Slime NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END <b>Taunt</b>

Python implementation:
class Slime(MinionCard):§    def __init__(self):§        super().__init__("Slime", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False)§§    def create_minion(self, p):§        return Minion(1, 2, taunt=True)§
Card: Spectral Spider NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class SpectralSpider(MinionCard):§    def __init__(self):§        super().__init__("Spectral Spider", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Stalagg NAME_END 7 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Python implementation:
class Stalagg(MinionCard):§    def __init__(self):§        super().__init__("Stalagg", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 4, deathrattle=Deathrattle(Summon(Thaddius()), PlayerSelector(), InGraveyard(Feugen())))§
Card: Stalagg NAME_END 7 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>Deathrattle:</b> If Feugen also died this game, summon Thaddius.

Python implementation:
class Stalagg(MinionCard):§    def __init__(self):§        super().__init__("Stalagg", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 4, deathrattle=Deathrattle(Summon(Thaddius()), PlayerSelector(), InGraveyard(Feugen())))§
Card: Stoneskin Gargoyle NAME_END 1 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END At the start of your turn, restore this minion to full Health.

Python implementation:
class StoneskinGargoyle(MinionCard):§    def __init__(self):§        super().__init__("Stoneskin Gargoyle", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 4, effects=[Effect(TurnStarted(), ActionTag(Heal(10000), SelfSelector()))])§
Card: Thaddius NAME_END 11 ATK_END 11 DEF_END 10 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Python implementation:
class Thaddius(MinionCard):§    def __init__(self):§        super().__init__("Thaddius", 10, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, False)§§    def create_minion(self, player):§        return Minion(11, 11)§
Card: Treant NAME_END 2 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class Treant(MinionCard):§    def __init__(self):§        super().__init__("Treant", 1, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON)§§    def create_minion(self, _):§        return Minion(2, 2)§
Card: Undertaker NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever you summon a minion with <b>Deathrattle</b>, gain +1 Attack.

Python implementation:
class Undertaker(MinionCard):§    def __init__(self):§        super().__init__("Undertaker", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 2, effects=[Effect(MinionSummoned(MinionHasDeathrattle()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§
Card: Unstable Ghoul NAME_END 1 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Taunt</b>. <b>Deathrattle:</b> Deal 1 damage to all minions.

Python implementation:
class UnstableGhoul(MinionCard):§    def __init__(self):§        super().__init__("Unstable Ghoul", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 3, deathrattle=Deathrattle(Damage(1), MinionSelector(players=BothPlayer())), taunt=True)§
Card: Webspinner NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Deathrattle:</b> Add a random Beast card to your hand.

Python implementation:
class Webspinner(MinionCard):§    def __init__(self):§        super().__init__("Webspinner", 1, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1, deathrattle=Deathrattle(AddCard(CardQuery(conditions=[IsType(MINION_TYPE.BEAST)])), PlayerSelector()))§
Card: Zombie Chow NAME_END 2 ATK_END 3 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Restore 5 Health to the enemy hero.

Python implementation:
class ZombieChow(MinionCard):§    def __init__(self):§        super().__init__("Zombie Chow", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, deathrattle=Deathrattle(Heal(5), HeroSelector(EnemyPlayer())))§
Card: Abomination NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Taunt</b>. <b>Deathrattle:</b> Deal 2 damage to ALL characters.

Python implementation:
class Abomination(MinionCard):§    def __init__(self):§        super().__init__("Abomination", 5, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(4, 4, deathrattle=Deathrattle(Damage(2), CharacterSelector(players=BothPlayer())), taunt=True)§
Card: Abusive Sergeant NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Give a minion +2 Attack this turn.

Python implementation:
class AbusiveSergeant(MinionCard):§    def __init__(self):§        super().__init__("Abusive Sergeant", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Give(BuffUntil(ChangeAttack(2), TurnEnded(player=CurrentPlayer()))), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 1)§
Card: Acolyte of Pain NAME_END 1 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 this minion takes damage, draw a card.

Python implementation:
class AcolyteOfPain(MinionCard):§    def __init__(self):§        super().__init__("Acolyte of Pain", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 3, effects=[Effect(Damaged(), ActionTag(Draw(), PlayerSelector()))])§
Card: Al'Akir the Windlord NAME_END 3 ATK_END 5 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Windfury, Charge, Divine Shield, Taunt</b>

Python implementation:
class AlAkirTheWindlord(MinionCard):§    def __init__(self):§        super().__init__("Al'Akir the Windlord", 8, CHARACTER_CLASS.SHAMAN, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(3, 5, windfury=True, charge=True, divine_shield=True, taunt=True)§
Card: Alarm-o-Bot NAME_END 0 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Rare RARITY_END At the start of your turn, swap this minion with a random one in your hand.

Python implementation:
class AlarmoBot(MinionCard):§    def __init__(self):§        super().__init__("Alarm-o-Bot", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(0, 3, effects=[Effect(TurnStarted(), ActionTag(SwapWithHand(), PlayerSelector()))])§
Card: Aldor Peacekeeper NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Change an enemy minion's Attack to 1.

Python implementation:
class AldorPeacekeeper(MinionCard):§    def __init__(self):§        super().__init__("Aldor Peacekeeper", 3, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE, battlecry=Battlecry(Give(SetAttack(1)), MinionSelector(condition=None, players=EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Ancestral Spirit NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Rare RARITY_END Give a minion "<b>Deathrattle:</b> Resummon this minion."

Python implementation:
class AncestralSpirit(SpellCard):§    def __init__(self):§        super().__init__("Ancestral Spirit", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.deathrattle.append(Deathrattle(Summon(self.target.card), PlayerSelector()))§
Card: Ancient Brewmaster NAME_END 5 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Return a friendly minion from the battlefield to your hand.

Python implementation:
class AncientBrewmaster(MinionCard):§    def __init__(self):§        super().__init__("Ancient Brewmaster", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Bounce(), MinionSelector(picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(5, 4)§
Card: Ancient Mage NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Give adjacent minions <b>Spell Damage +1</b>.

Python implementation:
class AncientMage(MinionCard):§    def __init__(self):§        super().__init__("Ancient Mage", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(Give(SpellDamage(1)), MinionSelector(condition=Adjacent())))§§    def create_minion(self, player):§        return Minion(2, 5)§
Card: Ancient Watcher NAME_END 4 ATK_END 5 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Can't attack.

Python implementation:
class AncientWatcher(MinionCard):§    def __init__(self):§        super().__init__("Ancient Watcher", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(4, 5, buffs=[Buff(CantAttack())])§
Card: Ancient of Lore NAME_END 5 ATK_END 5 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Choose One -</b> Draw 2 cards; or Restore 5 Health.

Python implementation:
class AncientOfLore(MinionCard):§    def __init__(self):§§        super().__init__("Ancient of Lore", 7, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC, choices=[§            Choice(AncientSecrets(), Heal(5), HeroSelector()),§            Choice(AncientTeachings(), Draw(3), PlayerSelector())§        ])§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: Ancient of War NAME_END 5 ATK_END 5 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Choose One</b> - NL +5 Attack; or +5 Health and <b>Taunt</b>.

Python implementation:
class AncientOfWar(MinionCard):§    def __init__(self):§§        super().__init__("Ancient of War", 7, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC, choices=[§            Choice(Health(), Give([Buff(ChangeHealth(5)), Buff(Taunt())]), SelfSelector()),§            Choice(Attack(), Give([Buff(ChangeAttack(5))]), SelfSelector()),§        ])§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: Angry Chicken NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Rare RARITY_END <b>Enrage:</b> +5 Attack.

Python implementation:
class AngryChicken(MinionCard):§    def __init__(self):§        super().__init__("Angry Chicken", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1, enrage=[Aura(ChangeAttack(5), SelfSelector())])§
Card: Arathi Weaponsmith NAME_END 3 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Equip a 2/2 weapon.

Python implementation:
class ArathiWeaponsmith(MinionCard):§    def __init__(self):§        super().__init__("Arathi Weaponsmith", 4, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, battlecry=Battlecry(Equip(BattleAxe()), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Argent Commander NAME_END 4 ATK_END 2 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Charge</b> NL <b>Divine Shield</b>

Python implementation:
class ArgentCommander(MinionCard):§    def __init__(self):§        super().__init__("Argent Commander", 6, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(4, 2, divine_shield=True, charge=True)§
Card: Argent Protector NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Give a friendly minion <b>Divine Shield</b>.

Python implementation:
class ArgentProtector(MinionCard):§    def __init__(self):§        super().__init__("Argent Protector", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON, battlecry=Battlecry(Give(DivineShield()), MinionSelector()))§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Argent Squire NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Divine Shield</b>

Python implementation:
class ArgentSquire(MinionCard):§    def __init__(self):§        super().__init__("Argent Squire", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 1, divine_shield=True)§
Card: Armorsmith NAME_END 1 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever a friendly minion takes damage, gain 1 Armor.

Python implementation:
class Armorsmith(MinionCard):§    def __init__(self):§        super().__init__("Armorsmith", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(1, 4, effects=[Effect(CharacterDamaged(condition=IsMinion()), ActionTag(IncreaseArmor(), HeroSelector()))])§
Card: Ashbringer NAME_END 5 ATK_END -1 DEF_END 5 COST_END 3 DUR_END Weapon TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Python implementation:
class Ashbringer(WeaponCard):§    def __init__(self):§        super().__init__("Ashbringer", 5, CHARACTER_CLASS.PALADIN, CARD_RARITY.LEGENDARY, False)§§    def create_weapon(self, player):§        weapon = Weapon(5, 3)§        return weapon§
Card: Auchenai Soulpriest NAME_END 3 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Rare RARITY_END Your cards and powers that restore Health now deal damage instead.

Python implementation:
class AuchenaiSoulpriest(MinionCard):§    def __init__(self):§        super().__init__("Auchenai Soulpriest", 4, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(3, 5, auras=[Aura(HealAsDamage(), PlayerSelector())])§
Card: Avenging Wrath NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal $8 damage randomly split among all enemies.

Python implementation:
class AvengingWrath(SpellCard):§    def __init__(self):§        super().__init__("Avenging Wrath", 6, CHARACTER_CLASS.PALADIN, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§        for i in range(0, player.effective_spell_damage(8)):§            targets = copy.copy(game.other_player.minions)§            targets.append(game.other_player.hero)§            target = game.random_choice(targets)§            target.damage(1, self)§
Card: Azure Drake NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Rare RARITY_END <b>Spell Damage +1</b>. <b>Battlecry:</b> Draw a card.

Python implementation:
class AzureDrake(MinionCard):§    def __init__(self):§        super().__init__("Azure Drake", 5, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.DRAGON, battlecry=Battlecry(Draw(), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(4, 4, spell_damage=1)§
Card: Bane of Doom NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal $2 damage to a character. If that kills it, summon a random Demon.

Python implementation:
class BaneOfDoom(SpellCard):§    def __init__(self):§        super().__init__("Bane of Doom", 5, CHARACTER_CLASS.WARLOCK, CARD_RARITY.EPIC, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        if self.target.health <= player.effective_spell_damage(2) and \ (isinstance(self.target, Minion) and not self.target.divine_shield):§            self.target.damage(player.effective_spell_damage(2), self)§            demons = CardQuery(conditions=[IsType(MINION_TYPE.DEMON)])§            demons.get_card(player, player, self).summon(player, game, len(player.minions))§        else:§            self.target.damage(player.effective_spell_damage(2), self)§
Card: Baron Geddon NAME_END 7 ATK_END 5 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END At the end of your turn, deal 2 damage to ALL other characters.

Python implementation:
class BaronGeddon(MinionCard):§    def __init__(self):§        super().__init__("Baron Geddon", 7, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 5, effects=[Effect(TurnEnded(), ActionTag(Damage(2), CharacterSelector(players=BothPlayer())))])§
Card: Battle Axe NAME_END 2 ATK_END -1 DEF_END 1 COST_END 2 DUR_END Weapon TYPE_END Warrior PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class BattleAxe(WeaponCard):§    def __init__(self):§        super().__init__("Battle Axe", 1, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, False)§§    def create_weapon(self, player):§        return Weapon(2, 2)§
Card: Battle Rage NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END Draw a card for each damaged friendly character.

Python implementation:
class BattleRage(SpellCard):§    def __init__(self):§        super().__init__("Battle Rage", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def use(self, player, game):§        def damaged_character(character):§            return character.health < character.calculate_max_health()§§        super().use(player, game)§§        characters = copy.copy(player.minions)§        characters.append(player.hero)§§        characters = [character for character in characters if damaged_character(character)]§§        for i in range(0, len(characters)):§            player.draw()§
Card: Bestial Wrath NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Epic RARITY_END Give a friendly Beast +2 Attack and <b>Immune</b> this turn.

Python implementation:
class BestialWrath(SpellCard):§    def __init__(self):§        super().__init__("Bestial Wrath", 1, CHARACTER_CLASS.HUNTER, CARD_RARITY.EPIC, target_func=hearthbreaker.targeting.find_friendly_minion_spell_target, filter_func=lambda minion: minion.card.minion_type is MINION_TYPE.BEAST and minion.spell_targetable())§§    def use(self, player, game):§        super().use(player, game)§        self.target.add_buff(BuffUntil(Immune(), TurnEnded(player=CurrentPlayer())))§        self.target.change_temp_attack(2)§
Card: Betrayal 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 Force an enemy minion to deal its damage to the minions next to it.

Python implementation:
class Betrayal(SpellCard):§    def __init__(self):§        super().__init__("Betrayal", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_enemy_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        left_minion = None§        right_minion = None§§        index = self.target.index§        if index > 0:§            left_minion = game.other_player.minions[index - 1]§        if index < min(len(game.other_player.minions) - 1, 6):§            right_minion = game.other_player.minions[index + 1]§§        original_immune = self.target.immune§        self.target.immune = True§        if left_minion is not None:§            left_minion.damage(self.target.calculate_attack(), self.target)§        if right_minion is not None:§            right_minion.damage(self.target.calculate_attack(), self.target)§        self.target.immune = original_immune§
Card: Big Game Hunter NAME_END 4 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Destroy a minion with an Attack of 7 or more.

Python implementation:
class BigGameHunter(MinionCard):§    def __init__(self):§        super().__init__("Big Game Hunter", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=Battlecry(Kill(), MinionSelector(AttackGreaterThan(6), BothPlayer())))§§    def create_minion(self, player):§        return Minion(4, 2)§
Card: Bite NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Rare RARITY_END Give your hero +4 Attack this turn and 4 Armor.

Python implementation:
class Bite(SpellCard):§    def __init__(self):§        super().__init__("Bite", 4, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        player.hero.change_temp_attack(4)§        player.hero.increase_armor(4)§
Card: Blessing of Wisdom NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END Choose a minion. Whenever it attacks, draw a card.

Python implementation:
class BlessingOfWisdom(SpellCard):§    def __init__(self):§        super().__init__("Blessing of Wisdom", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        if player is game.players[0]:§            draw_player = PlayerOne()§        else:§            draw_player = PlayerTwo()§        self.target.add_effect(Effect(Attack(), ActionTag(Draw(), PlayerSelector(draw_player))))§