dvitel/hearthstone huggingface dataset:
Card: Grove Tender NAME_END 2 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Choose One -</b> Give each player a Mana Crystal; or Each player draws a card.

Python implementation:
class GroveTender(MinionCard):§    def __init__(self):§        super().__init__("Grove Tender", 3, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE, choices=[§            Choice(GiftOfMana(), GiveManaCrystal(), PlayerSelector(players=BothPlayer())),§            Choice(GiftOfCards(), Draw(), PlayerSelector(players=BothPlayer()))§        ])§§    def create_minion(self, player):§        return Minion(2, 4)§
Card: Hemet Nesingwary NAME_END 6 ATK_END 3 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 a Beast.

Python implementation:
class HemetNesingwary(MinionCard):§    def __init__(self):§        super().__init__("Hemet Nesingwary", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, battlecry=Battlecry(Kill(), MinionSelector(IsType(MINION_TYPE.BEAST), players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(6, 3)§
Card: Hobgoblin NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END Whenever you play a 1-Attack minion, give it +2/+2.

Python implementation:
class Hobgoblin(MinionCard):§    def __init__(self):§        super().__init__("Hobgoblin", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(MinionPlaced(BaseAttackEqualTo(1)), ActionTag(Give([Buff(ChangeHealth(2)), Buff(ChangeAttack(2))]), TargetSelector()))])§
Card: Illuminator NAME_END 2 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END If you control a <b>Secret</b> at the end of your turn, restore 4 health to your hero.

Python implementation:
class Illuminator(MinionCard):§    def __init__(self):§        super().__init__("Illuminator", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(2, 4, effects=[Effect(TurnEnded(HasSecret()), ActionTag(Heal(4), HeroSelector()))])§
Card: Imp-losion NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $2-$4 damage to a minion. Summon a 1/1 Imp for each damage dealt.

Python implementation:
class Implosion(SpellCard):§    def __init__(self):§        super().__init__("Imp-losion", 4, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        amount = player.effective_spell_damage(game.random_amount(2, 4))§        had_shield = self.target.divine_shield§§        self.target.damage(amount, self)§§        if not had_shield:§            for i in range(0, amount):§                imp = Imp()§                imp.summon(player, game, len(player.minions))§
Card: Jeeves NAME_END 1 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Rare RARITY_END At the end of each player's turn, that player draws until they have 3 cards.

Python implementation:
class Jeeves(MinionCard):§    def __init__(self):§        super().__init__("Jeeves", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 4, effects=[Effect(TurnEnded(player=BothPlayer()), ActionTag(Draw(Difference(Count(CardSelector(players=CurrentPlayer())), value=3)), PlayerSelector(CurrentPlayer())))])§
Card: Junkbot NAME_END 1 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Epic RARITY_END Whenever a friendly Mech dies, gain +2/+2.

Python implementation:
class Junkbot(MinionCard):§    def __init__(self):§        super().__init__("Junkbot", 5, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 5, effects=[Effect(MinionDied(IsType(MINION_TYPE.MECH)), ActionTag(Give([Buff(ChangeAttack(2)), Buff(ChangeHealth(2))]), SelfSelector()))])§
Card: Kezan Mystic NAME_END 4 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> Take control of a random enemy <b>Secret</b>.

Python implementation:
class KezanMystic(MinionCard):§    def __init__(self):§        super().__init__("Kezan Mystic", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(ApplySecret(CARD_SOURCE.ENEMY_SECRETS), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(4, 3)§
Card: King of Beasts NAME_END 2 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Rare RARITY_END <b>Taunt</b>. <b>Battlecry:</b> Gain +1 Attack for each other Beast you have.

Python implementation:
class KingOfBeasts(MinionCard):§    def __init__(self):§        super().__init__("King of Beasts", 5, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST, battlecry=Battlecry(Give(Buff(ChangeAttack(Count(MinionSelector(IsType( MINION_TYPE.BEAST)))))), SelfSelector()))§§    def create_minion(self, player):§        return Minion(2, 6, taunt=True)§
Card: Light of the Naaru NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Rare RARITY_END Restore #3 Health. If the target is still damaged, summon a Lightwarden.

Python implementation:
class LightOfTheNaaru(SpellCard):§    def __init__(self):§        super().__init__("Light of the Naaru", 1, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.heal(player.effective_heal_power(3), self)§§        lightwarden = Lightwarden()§        if self.target is None:§            lightwarden.summon(player, game, len(player.minions))§        elif self.target.health != self.target.calculate_max_health():§            lightwarden.summon(player, game, len(player.minions))§
Card: Lightbomb NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal damage to each minion equal to its Attack.

Python implementation:
class Lightbomb(SpellCard):§    def __init__(self):§        super().__init__("Lightbomb", 6, CHARACTER_CLASS.PRIEST, CARD_RARITY.EPIC)§§    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.damage(player.effective_spell_damage(minion.calculate_attack()), self)§
Card: Lil' Exorcist NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Taunt</b> NL <b>Battlecry:</b> Gain +1/+1 for each enemy <b>Deathrattle</b> minion.

Python implementation:
class LilExorcist(MinionCard):§    def __init__(self):§        super().__init__("Lil' Exorcist", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(Give([Buff(ChangeAttack(Count(MinionSelector(MinionHasDeathrattle(), EnemyPlayer())))), Buff(ChangeHealth(Count(MinionSelector(MinionHasDeathrattle(), EnemyPlayer()))))]), SelfSelector()))§§    def create_minion(self, player):§        return Minion(2, 3, taunt=True)§
Card: Lost Tallstrider NAME_END 5 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END NIL

Python implementation:
class LostTallstrider(MinionCard):§    def __init__(self):§        super().__init__("Lost Tallstrider", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(5, 4)§
Card: Malorne NAME_END 9 ATK_END 7 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Legendary RARITY_END <b>Deathrattle:</b> Shuffle this minion into your deck.

Python implementation:
class Malorne(MinionCard):§    def __init__(self):§        super().__init__("Malorne", 7, CHARACTER_CLASS.DRUID, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(9, 7, deathrattle=[Deathrattle(AddCard(CardQuery(source=CARD_SOURCE.MINION, minion=SelfSelector()), add_to_deck=True), PlayerSelector()), Deathrattle(Remove(), SelfSelector())])§
Card: Mech-Bear-Cat NAME_END 7 ATK_END 6 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Mech RACE_END Rare RARITY_END Whenever this minion takes damage, add a <b>Spare Part</b> card to your hand.

Python implementation:
class MechBearCat(MinionCard):§    def __init__(self):§        super().__init__("Mech-Bear-Cat", 6, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(7, 6, effects=[Effect(Damaged(), ActionTag(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=spare_part_list)), PlayerSelector()))])§
Card: Mechanical Yeti NAME_END 4 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Deathrattle:</b> Give each player a <b>Spare Part.</b>

Python implementation:
class MechanicalYeti(MinionCard):§    def __init__(self):§        super().__init__("Mechanical Yeti", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        from hearthbreaker.cards.spells.neutral import spare_part_list§        return Minion(4, 5, deathrattle=Deathrattle(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=spare_part_list)), PlayerSelector(BothPlayer())))§
Card: Mechwarper NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END Your Mechs cost (1) less.

Python implementation:
class Mechwarper(MinionCard):§    def __init__(self):§        super().__init__("Mechwarper", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 3, auras=[Aura(ManaChange(-1), CardSelector(condition=IsType(MINION_TYPE.MECH)))])§
Card: Mekgineer Thermaplugg NAME_END 9 ATK_END 7 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Legendary RARITY_END Whenever an enemy minion dies, summon a Leper Gnome.

Python implementation:
class MekgineerThermaplugg(MinionCard):§    def __init__(self):§        super().__init__("Mekgineer Thermaplugg", 9, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(9, 7, effects=[Effect(MinionDied(player=EnemyPlayer()), ActionTag(Summon(LeperGnome()), PlayerSelector()))])§
Card: Metaltooth Leaper NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Battlecry</b>: Give your other Mechs +2 Attack.

Python implementation:
class MetaltoothLeaper(MinionCard):§    def __init__(self):§        super().__init__("Metaltooth Leaper", 3, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH, battlecry=Battlecry(Give(Buff(ChangeAttack(2))), MinionSelector(IsType(MINION_TYPE.MECH))))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Micro Machine NAME_END 1 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END At the start of each turn, gain +1 Attack.

Python implementation:
class MicroMachine(MinionCard):§    def __init__(self):§        super().__init__("Micro Machine", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 2, effects=[Effect(TurnStarted(player=BothPlayer()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§
Card: Mimiron's Head NAME_END 4 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Legendary RARITY_END At the start of your turn, if you have at least 3 Mechs, destroy them all and form V-07-TR-0N.

Python implementation:
class MimironsHead(MinionCard):§    def __init__(self):§        super().__init__("Mimiron's Head", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(4, 5, effects=[Effect(TurnStarted(), [ActionTag(Kill(), MinionSelector(IsType(MINION_TYPE.MECH, True)), GreaterThan(Count(MinionSelector(IsType(MINION_TYPE.MECH, True))), value=2)), ActionTag(Summon(V07TR0N()), PlayerSelector())])])§
Card: Mogor the Ogre NAME_END 7 ATK_END 6 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END All minions have a 50% chance to attack the wrong enemy.

Python implementation:
class MogorTheOgre(MinionCard):§    def __init__(self):§        super().__init__("Mogor the Ogre", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 6, effects=[Effect(CharacterAttack(None, BothPlayer()), ActionTag(ChangeTarget(§            CharacterSelector(NotCurrentTarget(), EnemyPlayer(), RandomPicker())), TargetSelector(),§            And(OneIn(2), OpponentMinionCountIsGreaterThan(0))))])§
Card: Muster for Battle NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END Summon three 1/1 Silver Hand Recruits. Equip a 1/4 Weapon.

Python implementation:
class MusterForBattle(SpellCard):§    def __init__(self):§        super().__init__("Muster for Battle", 3, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§§        for i in range(0, 3):§            dude = SilverHandRecruit()§            dude.summon(player, player.game, len(player.minions))§        justice = LightsJustice()§        hammer = justice.create_weapon(player)§        hammer.card = justice§        hammer.equip(player)§
Card: Neptulon NAME_END 7 ATK_END 7 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Battlecry:</b> Add 4 random Murlocs to your hand. <b>Overload:</b> (3)

Python implementation:
class Neptulon(MinionCard):§    def __init__(self):§        from hearthbreaker.cards.minions.neutral import BluegillWarrior, ColdlightOracle, ColdlightSeer, \§            GrimscaleOracle, MurlocRaider, MurlocTidecaller, MurlocTidehunter, MurlocWarleader, OldMurkEye, \§            Puddlestomper§        murloc_list = [BluegillWarrior(), ColdlightOracle(), ColdlightSeer(), GrimscaleOracle(), MurlocRaider(), MurlocTidecaller(), MurlocTidehunter(), MurlocWarleader(), OldMurkEye(), Puddlestomper(), SiltfinSpiritwalker()]§        super().__init__("Neptulon", 7, CHARACTER_CLASS.SHAMAN, CARD_RARITY.LEGENDARY, overload=3, battlecry=Battlecry(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=murloc_list), 4), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(7, 7)§
Card: Ogre Brute NAME_END 4 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END 50% chance to attack the wrong enemy.

Python implementation:
class OgreBrute(MinionCard):§    def __init__(self):§        super().__init__("Ogre Brute", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 4, effects=[Effect(Attack(), ActionTag(ChangeTarget(CharacterSelector(NotCurrentTarget(), EnemyPlayer(), RandomPicker())), SelfSelector(), And(OneIn(2), OpponentMinionCountIsGreaterThan(0))))])§
Card: Ogre Ninja NAME_END 6 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Stealth</b> NL 50% chance to attack the wrong enemy.

Python implementation:
class OgreNinja(MinionCard):§    def __init__(self):§        super().__init__("Ogre Ninja", 5, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(6, 6, stealth=True, effects=[Effect(Attack(), ActionTag(ChangeTarget( CharacterSelector(NotCurrentTarget(), EnemyPlayer(), RandomPicker())), SelfSelector(), And(OneIn(2), OpponentMinionCountIsGreaterThan(0))))])§
Card: Ogre Warmaul NAME_END 4 ATK_END -1 DEF_END 3 COST_END 2 DUR_END Weapon TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END 50% chance to attack the wrong enemy.

Python implementation:
class OgreWarmaul(WeaponCard):§    def __init__(self):§        super().__init__("Ogre Warmaul", 3, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def create_weapon(self, player):§        return Weapon(4, 2, effects=[Effect(CharacterAttack(IsHero()), ActionTag(ChangeTarget(CharacterSelector(NotCurrentTarget(), EnemyPlayer(), RandomPicker())), HeroSelector(), And(OneIn(2), OpponentMinionCountIsGreaterThan(0))))])§
Card: One-eyed Cheat NAME_END 4 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END Pirate RACE_END Rare RARITY_END Whenever you summon a Pirate, gain <b>Stealth</b>.

Python implementation:
class OneeyedCheat(MinionCard):§    def __init__(self):§        super().__init__("One-eyed Cheat", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE, minion_type=MINION_TYPE.PIRATE)§§    def create_minion(self, player):§        return Minion(4, 1, effects=[Effect(MinionSummoned(IsType(MINION_TYPE.PIRATE)), ActionTag(Give(Stealth()), SelfSelector()))])§
Card: Piloted Shredder NAME_END 4 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Deathrattle:</b> Summon a random 2-Cost minion.

Python implementation:
class PilotedShredder(MinionCard):§    def __init__(self):§        super().__init__("Piloted Shredder", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(4, 3, deathrattle=Deathrattle(Summon(CardQuery(conditions=[ManaCost(2), IsMinion()])), PlayerSelector()))§
Card: Puddlestomper NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Common RARITY_END NIL

Python implementation:
class Puddlestomper(MinionCard):§    def __init__(self):§        super().__init__("Puddlestomper", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MURLOC)§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Quartermaster NAME_END 2 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Give your Silver Hand Recruits +2/+2.

Python implementation:
class Quartermaster(MinionCard):§    def __init__(self):§        super().__init__("Quartermaster", 5, CHARACTER_CLASS.PALADIN, CARD_RARITY.EPIC, battlecry=Battlecry(Give([Buff(ChangeAttack(2)), Buff(ChangeHealth(2))]), MinionSelector(HasCardName("Silver Hand Recruit"))))§§    def create_minion(self, player):§        return Minion(2, 5)§
Card: Recombobulator NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Transform a friendly minion into a random minion with the same Cost.

Python implementation:
class Recombobulator(MinionCard):§    def __init__(self):§        super().__init__("Recombobulator", 2, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=Battlecry(Transform(CardQuery(conditions=[ ManaCost(Attribute("mana", SelfSelector())), IsMinion()])), MinionSelector(picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Recycle NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Rare RARITY_END Shuffle an enemy minion into your opponent's deck.

Python implementation:
class Recycle(SpellCard):§    def __init__(self):§        super().__init__("Recycle", 6, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_enemy_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        player.opponent.deck.put_back(self.target)§        self.target.remove_from_board()§
Card: Reversing Switch 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 Swap a minion's Attack and Health.

Python implementation:
class ReversingSwitch(SpellCard):§    def __init__(self):§        super().__init__("Reversing Switch", 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)§        temp_attack = self.target.calculate_attack()§        temp_health = self.target.health§        if temp_attack == 0:§            self.target.die(None)§        else:§            self.target.set_attack_to(temp_health)§            self.target.set_health_to(temp_attack)§
Card: Rusty Horn 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 <b>Taunt</b>.

Python implementation:
class RustyHorn(SpellCard):§    def __init__(self):§        super().__init__("Rusty Horn", 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(Taunt()))§
Card: Sabotage NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Epic RARITY_END Destroy a random enemy minion. <b>Combo</b>: And your opponent's weapon.

Python implementation:
class Sabotage(SpellCard):§    def __init__(self):§        super().__init__("Sabotage", 4, CHARACTER_CLASS.ROGUE, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§        targets = hearthbreaker.targeting.find_enemy_minion_battlecry_target(player.game, lambda x: True)§        target = game.random_choice(targets)§        target.die(None)§        game.check_delayed()§        if player.cards_played > 0 and game.other_player.weapon is not None:§            game.other_player.weapon.destroy()§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) >= 1§
Card: Salty Dog NAME_END 7 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Common RARITY_END NIL

Python implementation:
class SaltyDog(MinionCard):§    def __init__(self):§        super().__init__("Salty Dog", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.PIRATE)§§    def create_minion(self, player):§        return Minion(7, 4)§
Card: Seal of Light NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END Restore #4 Health to your hero and gain +2 Attack this turn.

Python implementation:
class SealOfLight(SpellCard):§    def __init__(self):§        super().__init__("Seal of Light", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        player.hero.heal(player.effective_heal_power(4), self)§        player.hero.change_temp_attack(2)§
Card: Shadowbomber NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Deal 3 damage to each hero.

Python implementation:
class Shadowbomber(MinionCard):§    def __init__(self):§        super().__init__("Shadowbomber", 1, CHARACTER_CLASS.PRIEST, CARD_RARITY.EPIC, battlecry=Battlecry(Damage(3), HeroSelector(players=BothPlayer())))§§    def create_minion(self, player):§        return Minion(2, 1)§