dvitel/hearthstone huggingface dataset:
Card: Shadowboxer NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END Mech RACE_END Rare RARITY_END Whenever a character is healed, deal 1 damage to a random enemy.

Python implementation:
class Shadowboxer(MinionCard):§    def __init__(self):§        super().__init__("Shadowboxer", 2, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(CharacterHealed(player=BothPlayer()), ActionTag(Damage(1), CharacterSelector(players=EnemyPlayer(), picker=RandomPicker(), condition=None)))])§
Card: Shielded Minibot NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Divine Shield</b>

Python implementation:
class ShieldedMinibot(MinionCard):§    def __init__(self):§        super().__init__("Shielded Minibot", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 2, divine_shield=True)§
Card: Shieldmaiden NAME_END 5 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Gain 5 Armor.

Python implementation:
class Shieldmaiden(MinionCard):§    def __init__(self):§        super().__init__("Shieldmaiden", 6, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE, battlecry=Battlecry(IncreaseArmor(5), HeroSelector()))§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: Ship's Cannon 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 Whenever you summon a Pirate, deal 2 damage to a random enemy.

Python implementation:
class ShipsCannon(MinionCard):§    def __init__(self):§        super().__init__("Ship's Cannon", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(MinionSummoned(IsType(MINION_TYPE.PIRATE)), ActionTag(Damage(2), CharacterSelector(None, EnemyPlayer(), RandomPicker())))])§
Card: Shrinkmeister NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Give a minion -2 Attack this turn.

Python implementation:
class Shrinkmeister(MinionCard):§    def __init__(self):§        super().__init__("Shrinkmeister", 2, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON, battlecry=Battlecry(Give(BuffUntil(ChangeAttack(-2), TurnEnded(player=CurrentPlayer()))), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Siege Engine NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END Mech RACE_END Rare RARITY_END Whenever you gain Armor, give this minion +1 Attack.

Python implementation:
class SiegeEngine(MinionCard):§    def __init__(self):§        super().__init__("Siege Engine", 5, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(5, 5, effects=[Effect(ArmorIncreased(), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§
Card: Snowchugger NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Freeze</b> any character damaged by this minion.

Python implementation:
class Snowchugger(MinionCard):§    def __init__(self):§        super().__init__("Snowchugger", 2, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(DidDamage(), ActionTag(Give(Frozen()), TargetSelector()))])§
Card: Soot Spewer NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Spell Damage +1</b>

Python implementation:
class SootSpewer(MinionCard):§    def __init__(self):§        super().__init__("Soot Spewer", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(3, 3, spell_damage=1)§
Card: Spider Tank NAME_END 3 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END NIL

Python implementation:
class SpiderTank(MinionCard):§    def __init__(self):§        super().__init__("Spider Tank", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(3, 4)§
Card: Steamwheedle Sniper NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Epic RARITY_END Your Hero Power can target minions.

Python implementation:
class SteamwheedleSniper(MinionCard):§    def __init__(self):§        super().__init__("Steamwheedle Sniper", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(2, 3, auras=[Aura(PowerTargetsMinions(), HeroSelector())])§
Card: Stonesplinter Trogg 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 Whenever your opponent casts a spell, gain +1 Attack.

Python implementation:
class StonesplinterTrogg(MinionCard):§    def __init__(self):§        super().__init__("Stonesplinter Trogg", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(SpellCast(player=EnemyPlayer()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§
Card: Target Dummy NAME_END 0 ATK_END 2 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Taunt</b>

Python implementation:
class TargetDummy(MinionCard):§    def __init__(self):§        super().__init__("Target Dummy", 0, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(0, 2, taunt=True)§
Card: Time Rewinder 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 Return a friendly minion to your hand.

Python implementation:
class TimeRewinder(SpellCard):§    def __init__(self):§        super().__init__("Time Rewinder", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_friendly_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.bounce()§
Card: Tinker's Sharpsword Oil NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Give your weapon +3 Attack. <b>Combo:</b> Give a random friendly minion +3 Attack.

Python implementation:
class TinkersSharpswordOil(SpellCard):§    def __init__(self):§        super().__init__("Tinker's Sharpsword Oil", 4, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        player.weapon.base_attack += 3§        player.hero.change_temp_attack(3)§        if player.cards_played > 0:§            targets = hearthbreaker.targeting.find_friendly_minion_battlecry_target(player.game, lambda x: x)§            if targets is not None:§                target = player.game.random_choice(targets)§                target.add_buff(Buff(ChangeAttack(3)))§§    def can_use(self, player, game):§        return super().can_use(player, game) and player.weapon is not None§
Card: Trade Prince Gallywix NAME_END 5 ATK_END 8 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Whenever your opponent casts a spell, gain a copy of it and give them a Coin.

Python implementation:
class TradePrinceGallywix(MinionCard):§    def __init__(self):§        super().__init__("Trade Prince Gallywix", 6, CHARACTER_CLASS.ROGUE, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(5, 8, effects=[Effect(SpellCast(Not(HasCardName("Gallywix's Coin")), EnemyPlayer()), ActionTag(AddCard(CardQuery(source=CARD_SOURCE.LAST_CARD)), PlayerSelector(FriendlyPlayer()))), Effect(SpellCast(Not(HasCardName("Gallywix's Coin")), EnemyPlayer()), ActionTag(AddCard(GallywixsCoin()), PlayerSelector(EnemyPlayer())))])§
Card: Tree of Life NAME_END -1 ATK_END -1 DEF_END 9 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END Restore all characters to full Health.

Python implementation:
class TreeOfLife(SpellCard):§    def __init__(self):§        super().__init__("Tree of Life", 9, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§§        targets = copy.copy(game.other_player.minions)§        targets.extend(game.current_player.minions)§        targets.append(game.other_player.hero)§        targets.append(game.current_player.hero)§        for target in targets:§            target.heal(player.effective_heal_power(target.calculate_max_health()), self)§
Card: Troggzor the Earthinator NAME_END 6 ATK_END 6 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Whenever your opponent casts a spell, summon a Burly Rockjaw Trogg.

Python implementation:
class TroggzorTheEarthinator(MinionCard):§    def __init__(self):§        super().__init__("Troggzor the Earthinator", 7, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(6, 6, effects=[Effect(SpellCast(player=EnemyPlayer()), ActionTag(Summon(BurlyRockjawTrogg()), PlayerSelector()))])§
Card: Unstable Portal NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Rare RARITY_END Add a random minion to your hand. It costs (3) less.

Python implementation:
class UnstablePortal(SpellCard):§    def __init__(self):§        super().__init__("Unstable Portal", 2, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        query = CardQuery(conditions=[IsMinion()])§        new_minon = query.get_card(player, player, self)§        new_minon.add_buff(Buff(ManaChange(-3)))§        player.hand.append(new_minon)§
Card: Upgraded Repair Bot NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Battlecry:</b> Give a friendly Mech +4 Health.

Python implementation:
class UpgradedRepairBot(MinionCard):§    def __init__(self):§        super().__init__("Upgraded Repair Bot", 5, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH, battlecry=Battlecry(Give(ChangeHealth(4)), MinionSelector(IsType(MINION_TYPE.MECH), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: V-07-TR-0N NAME_END 4 ATK_END 8 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Legendary RARITY_END <b>Charge</b> NL <b>Mega-Windfury</b> <i>(Can attack four times a turn.)</i>

Python implementation:
class V07TR0N(MinionCard):§    def __init__(self):§        super().__init__("V-07-TR-0N", 8, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, False, MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(4, 8, charge=True, buffs=[Buff(MegaWindfury())])§
Card: Velen's Chosen NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END Give a minion +2/+4 and <b>Spell Damage +1</b>.

Python implementation:
class VelensChosen(SpellCard):§    def __init__(self):§        super().__init__("Velen's Chosen", 3, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON, 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(4)§        self.target.add_buff(Buff(SpellDamage(1)))§
Card: Vitality Totem NAME_END 0 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END Totem RACE_END Rare RARITY_END At the end of your turn, restore 4 Health to your hero.

Python implementation:
class VitalityTotem(MinionCard):§    def __init__(self):§        super().__init__("Vitality Totem", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, minion_type=MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(0, 3, effects=[Effect(TurnEnded(), ActionTag(Heal(4), HeroSelector()))])§
Card: Wee Spellstopper NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END NIL RACE_END Epic RARITY_END Adjacent minions can't be targeted by spells or Hero Powers.

Python implementation:
class WeeSpellstopper(MinionCard):§    def __init__(self):§        super().__init__("Wee Spellstopper", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(2, 5, auras=[Aura(NoSpellTarget(), MinionSelector(Adjacent()))])§
Card: Whirling Blades 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 Attack.

Python implementation:
class WhirlingBlades(SpellCard):§    def __init__(self):§        super().__init__("Whirling Blades", 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.change_attack(1)§
Card: Whirling Zap-o-matic NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Windfury</b>

Python implementation:
class WhirlingZapomatic(MinionCard):§    def __init__(self):§        super().__init__("Whirling Zap-o-matic", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, p):§        return Minion(3, 2, windfury=True)§
Card: Anub'ar Ambusher NAME_END 5 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Return a random friendly minion to your hand.

Python implementation:
class AnubarAmbusher(MinionCard):§    def __init__(self):§        super().__init__("Anub'ar Ambusher", 4, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(5, 5, deathrattle=Deathrattle(Bounce(), MinionSelector(picker=RandomPicker())))§
Card: Avenge 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 one of your minions dies, give a random friendly minion +3/+2.

Python implementation:
class Avenge(SecretCard):§    def __init__(self):§        super().__init__("Avenge", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON)§§    def _reveal(self, dead_minion, attacker):§        if len([minion for minion in self.player.minions if not minion.dead]) > 0:§            target = self.player.game.random_choice(self.player.minions)§            target.change_attack(3)§            target.increase_health(2)§            super().reveal()§§    def activate(self, player):§        player.bind("minion_died", self._reveal)§§    def deactivate(self, player):§        player.unbind("minion_died", self._reveal)§
Card: Baron Rivendare NAME_END 1 ATK_END 7 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Your minions trigger their <b>Deathrattles</b> twice.

Python implementation:
class BaronRivendare(MinionCard):§    def __init__(self):§        super().__init__("Baron Rivendare", 4, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(1, 7, auras=[Aura(DoubleDeathrattle(), PlayerSelector())])§
Card: Dancing Swords 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 <b>Deathrattle:</b> Your opponent draws a card.

Python implementation:
class DancingSwords(MinionCard):§    def __init__(self):§        super().__init__("Dancing Swords", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 4, deathrattle=Deathrattle(Draw(), PlayerSelector(EnemyPlayer())))§
Card: Dark Cultist NAME_END 3 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Give a random friendly minion +3 Health.

Python implementation:
class DarkCultist(MinionCard):§    def __init__(self):§        super().__init__("Dark Cultist", 3, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 4, deathrattle=Deathrattle(Give(ChangeHealth(3)), MinionSelector(picker=RandomPicker())))§
Card: Duplicate 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 a friendly minion dies, put 2 copies of it into your hand.

Python implementation:
class Duplicate(SecretCard):§    def __init__(self):§        super().__init__("Duplicate", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON)§        self.player = None§§    def activate(self, player):§        player.bind("minion_died", self._reveal)§        self.player = player§§    def deactivate(self, player):§        player.unbind("minion_died", self._reveal)§        self.player = None§§    def _reveal(self, minion, by):§        for c in range(0, 2):§            if len(self.player.hand) < 10:§                new_card = type(minion.card)()§                self.player.hand.append(new_card)§                new_card.attach(new_card, self.player)§        super().reveal()§
Card: Echoing Ooze NAME_END 1 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> Summon an exact copy of this minion at the end of the turn.

Python implementation:
class EchoingOoze(MinionCard):§    def __init__(self):§        super().__init__("Echoing Ooze", 2, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=Battlecry(GiveEffect(Effect(TurnEnded(), ActionTag(Duplicate(SelfSelector()), PlayerSelector()))), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(1, 2)§
Card: Feugen NAME_END 4 ATK_END 7 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 Feugen(MinionCard):§    def __init__(self):§        super().__init__("Feugen", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(4, 7, deathrattle=Deathrattle(Summon(Thaddius()), PlayerSelector(), InGraveyard(Stalagg())))§
Card: Feugen NAME_END 4 ATK_END 7 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 Stalagg also died this game, summon Thaddius.

Python implementation:
class Feugen(MinionCard):§    def __init__(self):§        super().__init__("Feugen", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(4, 7, deathrattle=Deathrattle(Summon(Thaddius()), PlayerSelector(), InGraveyard(Stalagg())))§
Card: Haunted Creeper NAME_END 1 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Deathrattle:</b> Summon two 1/1 Spectral Spiders.

Python implementation:
class HauntedCreeper(MinionCard):§    def __init__(self):§        super().__init__("Haunted Creeper", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 2, deathrattle=Deathrattle(Summon(SpectralSpider(), 2), PlayerSelector()))§
Card: Kel'Thuzad NAME_END 6 ATK_END 8 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, summon all friendly minions that died this turn.

Python implementation:
class KelThuzad(MinionCard):§    def __init__(self):§        super().__init__("Kel'Thuzad", 8, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(6, 8, effects=[Effect(TurnEnded(player=BothPlayer()), ActionTag(ResurrectFriendly(), PlayerSelector()))])§
Card: Loatheb NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Battlecry:</b> Enemy spells cost (5) more next turn.

Python implementation:
class Loatheb(MinionCard):§    def __init__(self):§        super().__init__("Loatheb", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, battlecry=Battlecry(GiveAura(AuraUntil(ManaChange(5), CardSelector(condition=IsSpell()), TurnEnded())), PlayerSelector(players=EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: Mad Scientist NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Put a <b>Secret</b> from your deck into the battlefield.

Python implementation:
class MadScientist(MinionCard):§    def __init__(self):§        super().__init__("Mad Scientist", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 2, deathrattle=Deathrattle(ApplySecret(CARD_SOURCE.MY_DECK), PlayerSelector()))§
Card: Nerubian NAME_END 4 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class Nerubian(MinionCard):§    def __init__(self):§        super().__init__("Nerubian", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, False)§§    def create_minion(self, p):§        return Minion(4, 4)§
Card: Nerubian NAME_END 3 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class Nerubian(MinionCard):§    def __init__(self):§        super().__init__("Nerubian", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, False)§§    def create_minion(self, p):§        return Minion(4, 4)§
Card: Nerubian NAME_END 4 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END NIL

Python implementation:
class Nerubian(MinionCard):§    def __init__(self):§        super().__init__("Nerubian", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, False)§§    def create_minion(self, p):§        return Minion(4, 4)§
Card: Nerubian Egg NAME_END 0 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Deathrattle:</b> Summon a 4/4 Nerubian.

Python implementation:
class NerubianEgg(MinionCard):§    def __init__(self):§        super().__init__("Nerubian Egg", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(0, 2, deathrattle=Deathrattle(Summon(Nerubian()), PlayerSelector()))§
Card: Poison Seeds NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END Destroy all minions and summon 2/2 Treants to replace them.

Python implementation:
class PoisonSeeds(SpellCard):§    def __init__(self):§        super().__init__("Poison Seeds", 4, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        from hearthbreaker.cards.minions.druid import PoisonSeedsTreant§        targets = hearthbreaker.targeting.find_minion_spell_target(game, lambda m: True)§        for target in targets:§            target.die(None)§§        game.check_delayed()§§        for target in targets:§            PoisonSeedsTreant().summon(target.player, target.game, len(target.player.minions))§