dvitel/hearthstone huggingface dataset:
Card: Assassin's Blade NAME_END 3 ATK_END -1 DEF_END 5 COST_END 4 DUR_END Weapon TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END NIL

Python implementation:
class AssassinsBlade(WeaponCard):§    def __init__(self):§        super().__init__("Assassin's Blade", 5, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def create_weapon(self, player):§        return Weapon(3, 4)§
Card: Boulderfist Ogre NAME_END 6 ATK_END 7 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Free RARITY_END NIL

Python implementation:
class BoulderfistOgre(MinionCard):§    def __init__(self):§        super().__init__("Boulderfist Ogre", 6, CHARACTER_CLASS.ALL, CARD_RARITY.FREE)§§    def create_minion(self, player):§        return Minion(6, 7)§
Card: Deadly Poison NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Free RARITY_END Give your weapon +2 Attack.

Python implementation:
class DeadlyPoison(SpellCard):§    def __init__(self):§        super().__init__("Deadly Poison", 1, CHARACTER_CLASS.ROGUE, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§§        player.weapon.base_attack += 2§        player.hero.change_temp_attack(2)§§    def can_use(self, player, game):§        return super().can_use(player, game) and player.weapon is not None§
Card: Fire Elemental NAME_END 6 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Deal 3 damage.

Python implementation:
class FireElemental(MinionCard):§    def __init__(self):§        super().__init__("Fire Elemental", 6, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, battlecry=Battlecry(Damage(3), CharacterSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(6, 5)§
Card: Gnomish Inventor NAME_END 2 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> Draw a card.

Python implementation:
class GnomishInventor(MinionCard):§    def __init__(self):§        super().__init__("Gnomish Inventor", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Draw(), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(2, 4)§
Card: Heroic Strike NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Free RARITY_END Give your hero +4 Attack this turn.

Python implementation:
class HeroicStrike(SpellCard):§    def __init__(self):§        super().__init__("Heroic Strike", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§        player.hero.change_temp_attack(4)§
Card: Ironbark Protector NAME_END 8 ATK_END 8 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Taunt</b>

Python implementation:
class IronbarkProtector(MinionCard):§    def __init__(self):§        super().__init__("Ironbark Protector", 8, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(8, 8, taunt=True)§
Card: Mark of the Wild NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Free RARITY_END Give a minion <b>Taunt</b> and +2/+2.<i> (+2 Attack/+2 Health)</i>

Python implementation:
class MarkOfTheWild(SpellCard):§    def __init__(self):§        super().__init__("Mark of the Wild", 2, CHARACTER_CLASS.DRUID, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.change_attack(2)§        self.target.increase_health(2)§        self.target.taunt = True§
Card: Multi-Shot NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $3 damage to two random enemy minions.

Python implementation:
class MultiShot(SpellCard):§    def __init__(self):§        super().__init__("Multi-Shot", 4, CHARACTER_CLASS.HUNTER, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§§        targets = copy.copy(game.other_player.minions)§        for i in range(0, 2):§            target = game.random_choice(targets)§            targets.remove(target)§            target.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: Power Word: Shield NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Free RARITY_END Give a minion +2 Health. NL Draw a card.

Python implementation:
class PowerWordShield(SpellCard):§    def __init__(self):§        super().__init__("Power Word: Shield", 1, CHARACTER_CLASS.PRIEST, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.increase_health(2)§        player.draw()§
Card: Sen'jin Shieldmasta NAME_END 3 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Free RARITY_END <b>Taunt</b>

Python implementation:
class SenjinShieldmasta(MinionCard):§    def __init__(self):§        super().__init__("Sen'jin Shieldmasta", 4, CHARACTER_CLASS.ALL, CARD_RARITY.FREE)§§    def create_minion(self, player):§        return Minion(3, 5, taunt=True)§
Card: Sinister Strike NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $3 damage to the enemy hero.

Python implementation:
class SinisterStrike(SpellCard):§    def __init__(self):§        super().__init__("Sinister Strike", 1, CHARACTER_CLASS.ROGUE, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§§        game.other_player.hero.damage(player.effective_spell_damage(3), self)§
Card: Succubus NAME_END 4 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Free RARITY_END <b>Battlecry:</b> Discard a random card.

Python implementation:
class Succubus(MinionCard):§    def __init__(self):§        super().__init__("Succubus", 2, CHARACTER_CLASS.WARLOCK, CARD_RARITY.FREE, minion_type=MINION_TYPE.DEMON, battlecry=Battlecry(Discard(), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(4, 3)§
Card: War Golem NAME_END 7 ATK_END 7 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END NIL

Python implementation:
class WarGolem(MinionCard):§    def __init__(self):§        super().__init__("War Golem", 7, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(7, 7)§
Card: Acidmaw NAME_END 4 ATK_END 2 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Legendary RARITY_END Whenever another minion takes damage, destroy it.

Python implementation:
class Acidmaw(MinionCard):§    def __init__(self):§        super().__init__("Acidmaw", 7, CHARACTER_CLASS.HUNTER, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(4, 2, effects=[Effect(CharacterDamaged(MinionIsNotTarget(), BothPlayer()), [ActionTag(Kill(), TargetSelector())])])§
Card: Boar NAME_END 4 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END NIL RARITY_END <b>Charge</b>

Python implementation:
class Boar(MinionCard):§    def __init__(self):§        super().__init__("Boar", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Anodized Robo Cub NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Taunt</b>. <b>Choose One -</b> NL +1 Attack; or +1 Health.

Python implementation:
class AnodizedRoboCub(MinionCard):§    def __init__(self):§        super().__init__("Anodized Robo Cub", 2, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH, choices=[Choice(AttackMode(), Give([Buff(ChangeAttack(1))]), SelfSelector()), Choice(TankMode(), Give([Buff(ChangeHealth(1))]), SelfSelector())])§§    def create_minion(self, player):§        return Minion(2, 2, taunt=True)§
Card: Burrowing Mine NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END NIL RARITY_END When you draw this, it explodes. You take 10 damage and draw a card.

Python implementation:
class BurrowingMine(SpellCard):§    def __init__(self):§        super().__init__("Burrowing Mine", 0, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, False, effects=[Effect(Drawn(), ActionTag(Damage(10), HeroSelector())), Effect(Drawn(), ActionTag(Discard(query=CardQuery(source=CARD_SOURCE.LAST_DRAWN)), PlayerSelector())), Effect(Drawn(), ActionTag(Draw(), PlayerSelector()))])§§    def use(self, player, game):§        super().use(player, game)§
Card: Crackle 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 Deal $3-$6 damage. <b>Overload:</b> (1)

Python implementation:
class Crackle(SpellCard):§    def __init__(self):§        super().__init__("Crackle", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_spell_target, overload=1)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.damage(player.effective_spell_damage(game.random_amount(3, 6)), self)§
Card: Emergency Coolant NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END <b>Freeze</b> a minion.

Python implementation:
class EmergencyCoolant(SpellCard):§    def __init__(self):§        super().__init__("Emergency Coolant", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.add_buff(Buff(Frozen()))§
Card: Flying Machine NAME_END 1 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Windfury</b>

Python implementation:
class FlyingMachine(MinionCard):§    def __init__(self):§        super().__init__("Flying Machine", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 4, windfury=True)§
Card: Goblin Auto-Barber NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Battlecry</b>: Give your weapon +1 Attack.

Python implementation:
class GoblinAutoBarber(MinionCard):§    def __init__(self):§        super().__init__("Goblin Auto-Barber", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH, battlecry=Battlecry(IncreaseWeaponAttack(1), WeaponSelector()))§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Iron Sensei NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END Mech RACE_END Rare RARITY_END At the end of your turn, give another friendly Mech +2/+2.

Python implementation:
class IronSensei(MinionCard):§    def __init__(self):§        super().__init__("Iron Sensei", 3, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 2, effects=[Effect(TurnEnded(), ActionTag(Give([Buff(ChangeAttack(2)), Buff(ChangeHealth(2))]), MinionSelector(IsType(MINION_TYPE.MECH), picker=RandomPicker())))])§
Card: Mal'Ganis NAME_END 9 ATK_END 7 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Legendary RARITY_END Your other Demons have +2/+2. NL Your hero is <b>Immune</b>.

Python implementation:
class MalGanis(MinionCard):§    def __init__(self):§        super().__init__("Mal'Ganis", 9, CHARACTER_CLASS.WARLOCK, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(9, 7, auras=[Aura(ChangeHealth(2), MinionSelector(IsType(MINION_TYPE.DEMON))), Aura(ChangeAttack(2), MinionSelector(IsType(MINION_TYPE.DEMON))), Aura(Immune(), HeroSelector())])§
Card: Mistress of Pain NAME_END 1 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Rare RARITY_END Whenever this minion deals damage, restore that much Health to your hero.

Python implementation:
class MistressOfPain(MinionCard):§    def __init__(self):§        super().__init__("Mistress of Pain", 2, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(1, 4, effects=[Effect(DidDamage(), ActionTag(Heal(EventValue()), HeroSelector()))])§
Card: Powermace NAME_END 3 ATK_END -1 DEF_END 3 COST_END 2 DUR_END Weapon TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Deathrattle</b>: Give a random friendly Mech +2/+2.

Python implementation:
class Powermace(WeaponCard):§    def __init__(self):§        super().__init__("Powermace", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE)§§    def create_weapon(self, player):§        return Weapon(3, 2, deathrattle=Deathrattle(Give([Buff(ChangeHealth(2)), Buff(ChangeAttack(2))]), MinionSelector(IsType(MINION_TYPE.MECH), picker=RandomPicker())))§
Card: Screwjank Clunker NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Battlecry</b>: Give a friendly Mech +2/+2.

Python implementation:
class ScrewjankClunker(MinionCard):§    def __init__(self):§        super().__init__("Screwjank Clunker", 4, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH, battlecry=Battlecry(Give([Buff(ChangeHealth(2)), Buff(ChangeAttack(2))]), MinionSelector(IsType(MINION_TYPE.MECH), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 5)§
Card: Sneed's Old Shredder NAME_END 5 ATK_END 7 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Legendary RARITY_END <b>Deathrattle:</b> Summon a random legendary minion.

Python implementation:
class SneedsOldShredder(MinionCard):§    def __init__(self):§        super().__init__("Sneed's Old Shredder", 8, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(5, 7, deathrattle=Deathrattle(Summon(CardQuery(conditions=[IsRarity(CARD_RARITY.LEGENDARY), IsMinion()])), PlayerSelector()))§
Card: Toshley NAME_END 5 ATK_END 7 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Battlecry and Deathrattle:</b> Add a <b>Spare Part</b> card to your hand.

Python implementation:
class Toshley(MinionCard):§    def __init__(self):§        from hearthbreaker.cards.spells.neutral import spare_part_list§        super().__init__("Toshley", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, battlecry=Battlecry(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=spare_part_list)), PlayerSelector()))§§    def create_minion(self, player):§        from hearthbreaker.cards.spells.neutral import spare_part_list§        return Minion(5, 7, deathrattle=Deathrattle(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=spare_part_list)), PlayerSelector()))§
Card: Warbot NAME_END 1 ATK_END 3 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Enrage:</b> +1 Attack.

Python implementation:
class Warbot(MinionCard):§    def __init__(self):§        super().__init__("Warbot", 1, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 3, enrage=[Aura(ChangeAttack(1), SelfSelector())])§
Card: Deathlord NAME_END 2 ATK_END 8 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Taunt. Deathrattle:</b> Your opponent puts a minion from their deck into the battlefield.

Python implementation:
class Deathlord(MinionCard):§    def __init__(self):§        super().__init__("Deathlord", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(2, 8, taunt=True, deathrattle=Deathrattle(Summon(CardQuery(conditions=[IsMinion()], source=CARD_SOURCE.MY_DECK)), PlayerSelector(EnemyPlayer())))§
Card: Nerub'ar Weblord NAME_END 1 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Minions with <b>Battlecry</b> cost (2) more.

Python implementation:
class NerubarWeblord(MinionCard):§    def __init__(self):§        super().__init__("Nerub'ar Weblord", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 4, auras=[Aura(ManaChange(2), CardSelector(BothPlayer(), HasBattlecry()))])§
Card: Spectral Knight NAME_END 4 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Can't be targeted by spells or Hero Powers.

Python implementation:
class SpectralKnight(MinionCard):§    def __init__(self):§        super().__init__("Spectral Knight", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 6, spell_targetable=False)§
Card: Wailing Soul NAME_END 3 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: Silence</b> your other minions.

Python implementation:
class WailingSoul(MinionCard):§    def __init__(self):§        super().__init__("Wailing Soul", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(Silence(), MinionSelector()))§§    def create_minion(self, player):§        return Minion(3, 5)§
Card: Amani Berserker NAME_END 2 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>Enrage:</b> +3 Attack

Python implementation:
class AmaniBerserker(MinionCard):§    def __init__(self):§        super().__init__("Amani Berserker", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, enrage=[Aura(ChangeAttack(3), SelfSelector())])§
Card: Archmage Antonidas NAME_END 5 ATK_END 7 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Whenever you cast a spell, add a 'Fireball' spell to your hand.

Python implementation:
class ArchmageAntonidas(MinionCard):§    def __init__(self):§        super().__init__("Archmage Antonidas", 7, CHARACTER_CLASS.MAGE, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(5, 7, effects=[Effect(SpellCast(), ActionTag(AddCard(hearthbreaker.cards.Fireball()), PlayerSelector()))])§
Card: Bananas NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END Give a minion +1/+1.

Python implementation:
class Bananas(SpellCard):§    def __init__(self):§        super().__init__("Bananas", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.change_attack(1)§        self.target.increase_health(1)§
Card: Blessed Champion NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END Double a minion's Attack.

Python implementation:
class BlessedChampion(SpellCard):§    def __init__(self):§        super().__init__("Blessed Champion", 5, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.add_buff(Buff(DoubleAttack()))§
Card: Cabal Shadow Priest NAME_END 4 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Take control of an enemy minion that has 2 or less Attack.

Python implementation:
class CabalShadowPriest(MinionCard):§    def __init__(self):§        super().__init__("Cabal Shadow Priest", 6, CHARACTER_CLASS.PRIEST, CARD_RARITY.EPIC, battlecry=Battlecry(Steal(), MinionSelector(AttackLessThanOrEqualTo(2), players=EnemyPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(4, 5)§
Card: Cone of Cold NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Freeze</b> a minion and the minions next to it, and deal $1 damage to them.

Python implementation:
class ConeOfCold(SpellCard):§    def __init__(self):§        super().__init__("Cone of Cold", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.add_buff(Buff(Frozen()))§        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(1), self)§            minion.add_buff(Buff(Frozen()))§§        self.target.damage(player.effective_spell_damage(1), self)§§        if self.target.index > 0:§            minion = self.target.player.minions[index - 1]§            minion.damage(player.effective_spell_damage(1), self)§            minion.add_buff(Buff(Frozen()))§
Card: Defender of Argus NAME_END 2 ATK_END 3 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 +1/+1 and <b>Taunt</b>.

Python implementation:
class DefenderOfArgus(MinionCard):§    def __init__(self):§        super().__init__("Defender of Argus", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(Give([ Buff(Taunt()), Buff(ChangeAttack(1)), Buff(ChangeHealth(1)) ]), MinionSelector(Adjacent())))§§    def create_minion(self, player):§        return Minion(2, 3)§
Card: Doomhammer NAME_END 2 ATK_END -1 DEF_END 5 COST_END 8 DUR_END Weapon TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Windfury, Overload:</b> (2)

Python implementation:
class Doomhammer(WeaponCard):§    def __init__(self):§        super().__init__("Doomhammer", 5, CHARACTER_CLASS.SHAMAN, CARD_RARITY.EPIC, overload=2)§§    def create_weapon(self, player):§        return Weapon(2, 8, buffs=[Buff(Windfury())])§
Card: Earth Shock 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 <b>Silence</b> a minion, then deal $1 damage to it.

Python implementation:
class EarthShock(SpellCard):§    def __init__(self):§        super().__init__("Earth Shock", 1, 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.silence()§        self.target.damage(player.effective_spell_damage(1), self)§
Card: Eye for an Eye 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 <b>Secret:</b> When your hero takes damage, deal that much damage to the enemy hero.

Python implementation:
class EyeForAnEye(SecretCard):§    def __init__(self):§        super().__init__("Eye for an Eye", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON)§§    def _reveal(self, character, attacker, amount):§        if character.is_hero():§            character.player.opponent.hero.damage(amount, self)§        super().reveal()§§    def activate(self, player):§        player.bind("character_damaged", self._reveal)§§    def deactivate(self, player):§        player.unbind("character_damaged", self._reveal)§