dvitel/hearthstone huggingface dataset:
Card: Kidnapper NAME_END 5 ATK_END 3 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Combo:</b> Return a minion to its owner's hand.

Python implementation:
class Kidnapper(MinionCard):§    def __init__(self):§        super().__init__("Kidnapper", 6, CHARACTER_CLASS.ROGUE, CARD_RARITY.EPIC, combo=Battlecry(Bounce(), MinionSelector(picker=UserPicker(), players=BothPlayer())))§§    def create_minion(self, player):§        return Minion(5, 3)§
Card: King Krush NAME_END 8 ATK_END 8 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Legendary RARITY_END <b>Charge</b>

Python implementation:
class KingKrush(MinionCard):§    def __init__(self):§        super().__init__("King Krush", 9, CHARACTER_CLASS.HUNTER, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(8, 8, charge=True)§
Card: King Mukla NAME_END 5 ATK_END 5 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Legendary RARITY_END <b>Battlecry:</b> Give your opponent 2 Bananas.

Python implementation:
class KingMukla(MinionCard):§    def __init__(self):§        super().__init__("King Mukla", 3, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.BEAST, battlecry=Battlecry(AddCard(Bananas(), 2), PlayerSelector(EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: Laughing Sister NAME_END 3 ATK_END 5 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Dream PLAYER_CLS_END NIL RACE_END NIL RARITY_END Can't be targeted by spells or Hero Powers.

Python implementation:
class LaughingSister(MinionCard):§    def __init__(self):§        super().__init__("Laughing Sister", 3, CHARACTER_CLASS.DREAM, CARD_RARITY.COMMON, False)§§    def create_minion(self, player):§        return Minion(3, 5, spell_targetable=False)§
Card: Lava Burst NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $5 damage. <b>Overload:</b> (2)

Python implementation:
class LavaBurst(SpellCard):§    def __init__(self):§        super().__init__("Lava Burst", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_spell_target, overload=2)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.damage(player.effective_spell_damage(5), self)§
Card: Lay on Hands NAME_END -1 ATK_END -1 DEF_END 8 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Epic RARITY_END Restore #8 Health. Draw 3 cards.

Python implementation:
class LayOnHands(SpellCard):§    def __init__(self):§        super().__init__("Lay on Hands", 8, CHARACTER_CLASS.PALADIN, CARD_RARITY.EPIC, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.heal(player.effective_heal_power(8), self)§        player.draw()§        player.draw()§        player.draw()§
Card: Leeroy Jenkins NAME_END 6 ATK_END 2 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Charge</b>. <b>Battlecry:</b> Summon two 1/1 Whelps for your opponent.

Python implementation:
class LeeroyJenkins(MinionCard):§    def __init__(self):§        super().__init__("Leeroy Jenkins", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, battlecry=Battlecry(Summon(Whelp(), 2), PlayerSelector(players=EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(6, 2, charge=True)§
Card: Leper Gnome 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>Deathrattle:</b> Deal 2 damage to the enemy hero.

Python implementation:
class LeperGnome(MinionCard):§    def __init__(self):§        super().__init__("Leper Gnome", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 1, deathrattle=Deathrattle(Damage(2), HeroSelector(EnemyPlayer())))§
Card: Lightning Bolt NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $3 damage. <b>Overload:</b> (1)

Python implementation:
class LightningBolt(SpellCard):§    def __init__(self):§        super().__init__("Lightning Bolt", 1, 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(3), self)§
Card: Lightning Storm NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $2-$3 damage to all enemy minions. <b>Overload:</b> (2)

Python implementation:
class LightningStorm(SpellCard):§    def __init__(self):§        super().__init__("Lightning Storm", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, overload=2)§§    def use(self, player, game):§        super().use(player, game)§§        for minion in copy.copy(game.other_player.minions):§            minion.damage(player.effective_spell_damage(game.random_amount(2, 3)), self)§
Card: Lightspawn NAME_END 0 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END This minion's Attack is always equal to its Health.

Python implementation:
class Lightspawn(MinionCard):§    def __init__(self):§        super().__init__("Lightspawn", 4, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(0, 5, buffs=[Buff(AttackEqualsHealth())])§
Card: Loot Hoarder NAME_END 2 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Draw a card.

Python implementation:
class LootHoarder(MinionCard):§    def __init__(self):§        super().__init__("Loot Hoarder", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 1, deathrattle=Deathrattle(Draw(), PlayerSelector()))§
Card: Lord Jaraxxus NAME_END 0 ATK_END 15 DEF_END 0 COST_END -1 DUR_END Hero TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Legendary RARITY_END NIL

Python implementation:
class LordJaraxxus(MinionCard):§    def __init__(self):§        super().__init__("Lord Jaraxxus", 9, CHARACTER_CLASS.WARLOCK, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DEMON, battlecry=(Battlecry(ReplaceHeroWithMinion(Jaraxxus()), HeroSelector()), Battlecry(Remove(), SelfSelector()), Battlecry(Equip(BloodFury()), PlayerSelector())))§§    def create_minion(self, player):§        return Minion(3, 15)§
Card: Lord Jaraxxus NAME_END 3 ATK_END 15 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Legendary RARITY_END <b>Battlecry:</b> Destroy your hero and replace it with Lord Jaraxxus.

Python implementation:
class LordJaraxxus(MinionCard):§    def __init__(self):§        super().__init__("Lord Jaraxxus", 9, CHARACTER_CLASS.WARLOCK, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DEMON, battlecry=(Battlecry(ReplaceHeroWithMinion(Jaraxxus()), HeroSelector()), Battlecry(Remove(), SelfSelector()), Battlecry(Equip(BloodFury()), PlayerSelector())))§§    def create_minion(self, player):§        return Minion(3, 15)§
Card: Lorewalker Cho NAME_END 0 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Whenever a player casts a spell, put a copy into the other player’s hand.

Python implementation:
class LorewalkerCho(MinionCard):§    def __init__(self):§        super().__init__("Lorewalker Cho", 2, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(0, 4, effects=[Effect(SpellCast(player=BothPlayer()), ActionTag(AddCard(CardQuery(source=CARD_SOURCE.LAST_CARD)), PlayerSelector(OtherPlayer())))])§
Card: Mad Bomber NAME_END 3 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>Battlecry:</b> Deal 3 damage randomly split between all other characters.

Python implementation:
class MadBomber(MinionCard):§    def __init__(self):§        super().__init__("Mad Bomber", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Damage(1), CharacterSelector(players=BothPlayer(), picker=RandomPicker(3))))§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Malygos NAME_END 4 ATK_END 12 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Legendary RARITY_END <b>Spell Damage +5</b>

Python implementation:
class Malygos(MinionCard):§    def __init__(self):§        super().__init__("Malygos", 9, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        return Minion(4, 12, spell_damage=5)§
Card: Mana Addict NAME_END 1 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever you cast a spell, gain +2 Attack this turn.

Python implementation:
class ManaAddict(MinionCard):§    def __init__(self):§        super().__init__("Mana Addict", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(1, 3, effects=[Effect(SpellCast(), ActionTag(Give(BuffUntil(ChangeAttack(2), TurnEnded())), SelfSelector()))])§
Card: Mana Tide Totem NAME_END 0 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END Totem RACE_END Rare RARITY_END At the end of your turn, draw a card.

Python implementation:
class ManaTideTotem(MinionCard):§    def __init__(self):§        super().__init__("Mana Tide Totem", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, minion_type=MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(0, 3, effects=[Effect(TurnEnded(), ActionTag(Draw(), PlayerSelector()))])§
Card: Mark of Nature NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Choose One</b> - Give a minion +4 Attack; or +4 Health and <b>Taunt</b>.

Python implementation:
class MarkOfNature(SpellCard):§    def __init__(self):§        super().__init__("Mark of Nature", 3, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        class MarkOfNatureAttack(ChoiceCard):§            def __init__(self):§                super().__init__("Mark of Nature +4 Attack", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§            def use(self, player, game):§                target.change_attack(4)§§        class MarkOfNatureHealth(ChoiceCard):§            def __init__(self):§                super().__init__("Mark of Nature +4 Health", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§            def use(self, player, game):§                target.increase_health(4)§                target.taunt = True§§        super().use(player, game)§        target = self.target§        option = game.current_player.agent.choose_option([MarkOfNatureAttack(), MarkOfNatureHealth()], player)§        option.use(player, game)§
Card: Mass Dispel NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Silence</b> all enemy minions. Draw a card.

Python implementation:
class MassDispel(SpellCard):§    def __init__(self):§        super().__init__("Mass Dispel", 4, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§§        for minion in game.other_player.minions:§            minion.silence()§§        player.draw()§
Card: Master Swordsmith NAME_END 1 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END At the end of your turn, give another random friendly minion +1 Attack.

Python implementation:
class MasterSwordsmith(MinionCard):§    def __init__(self):§        super().__init__("Master Swordsmith", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(1, 3, effects=[Effect(TurnEnded(), ActionTag(Give(ChangeAttack(1)), MinionSelector(picker=RandomPicker())))])§
Card: Master of Disguise NAME_END 4 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Give a friendly minion <b>Stealth</b>.

Python implementation:
class MasterOfDisguise(MinionCard):§    def __init__(self):§        super().__init__("Master of Disguise", 4, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE, battlecry=Battlecry(Give(Stealth()), MinionSelector(picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Millhouse Manastorm NAME_END 4 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Battlecry:</b> Enemy spells cost (0) next turn.

Python implementation:
class MillhouseManastorm(MinionCard):§    def __init__(self):§        super().__init__("Millhouse Manastorm", 2, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, battlecry=Battlecry(GiveAura(AuraUntil(ManaChange(-100), CardSelector(condition=IsSpell()), TurnEnded())), PlayerSelector(players=EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Mind Control Tech NAME_END 3 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>Battlecry:</b> If your opponent has 4 or more minions, take control of one at random.

Python implementation:
class MindControlTech(MinionCard):§    def __init__(self):§        super().__init__("Mind Control Tech", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(Steal(), MinionSelector(players=EnemyPlayer(), condition=None, picker=RandomPicker()), OpponentMinionCountIsGreaterThan(3)) )§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Mindgames NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Epic RARITY_END Put a copy of a random minion from your opponent's deck into the battlefield.

Python implementation:
class Mindgames(SpellCard):§    def __init__(self):§        super().__init__("Mindgames", 4, CHARACTER_CLASS.PRIEST, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§§        minion_card = game.random_draw(game.other_player.deck.cards, lambda c: not c.drawn and isinstance(c, MinionCard))§        if not minion_card:§            minion_card = ShadowOfNothing()§        else:§            minion_card = copy.copy(minion_card)§        minion_card.drawn = True§        minion_card.summon(player, game, 0)§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(player.minions) < 7§
Card: Mirror Entity NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Secret:</b> When your opponent plays a minion, summon a copy of it.

Python implementation:
class MirrorEntity(SecretCard):§    def __init__(self):§        super().__init__("Mirror Entity", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON)§        self.player = None§§    def _reveal(self, minion):§        if len(self.player.minions) < 7:§            mirror = minion.copy(self.player)§            mirror.add_to_board(len(self.player.minions))§            minion.player.trigger("minion_summoned", mirror)§            minion.player.trigger("after_added", mirror)§            super().reveal()§§    def activate(self, player):§        player.game.current_player.bind("minion_played", self._reveal)§        self.player = player§§    def deactivate(self, player):§        player.game.current_player.unbind("minion_played", self._reveal)§        self.player = None§
Card: Molten Giant NAME_END 8 ATK_END 8 DEF_END 20 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END Costs (1) less for each damage your hero has taken.

Python implementation:
class MoltenGiant(MinionCard):§    def __init__(self):§        super().__init__("Molten Giant", 20, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, buffs=[Buff(ManaChange(Attribute("damage", HeroSelector()), -1))])§§    def create_minion(self, player):§        return Minion(8, 8)§
Card: Mortal Strike NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $4 damage. If you have 12 or less Health, deal $6 instead.

Python implementation:
class MortalStrike(SpellCard):§    def __init__(self):§        super().__init__("Mortal Strike", 4, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        if player.hero.health <= 12:§            self.target.damage(player.effective_spell_damage(6), self)§        else:§            self.target.damage(player.effective_spell_damage(4), self)§
Card: Mountain Giant NAME_END 8 ATK_END 8 DEF_END 12 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END Costs (1) less for each other card in your hand.

Python implementation:
class MountainGiant(MinionCard):§    def __init__(self):§        super().__init__("Mountain Giant", 12, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, buffs=[Buff(ManaChange(Count(CardSelector()), -1))])§§    def create_minion(self, player):§        return Minion(8, 8)§
Card: Murloc Tidecaller NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Rare RARITY_END Whenever a Murloc is summoned, gain +1 Attack.

Python implementation:
class MurlocTidecaller(MinionCard):§    def __init__(self):§        super().__init__("Murloc Tidecaller", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MURLOC)§§    def create_minion(self, player):§        return Minion(1, 2, effects=[(Effect(MinionSummoned(IsType(MINION_TYPE.MURLOC), player=BothPlayer()), ActionTag(Give(ChangeAttack(1)), SelfSelector())))])§
Card: Murloc Warleader NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Epic RARITY_END ALL other Murlocs have +2/+1.

Python implementation:
class MurlocWarleader(MinionCard):§    def __init__(self):§        super().__init__("Murloc Warleader", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, minion_type=MINION_TYPE.MURLOC)§§    def create_minion(self, player):§        return Minion(3, 3, auras=[Aura(ChangeAttack(2), MinionSelector(IsType(MINION_TYPE.MURLOC), BothPlayer())), Aura(ChangeHealth(1), MinionSelector(IsType(MINION_TYPE.MURLOC), BothPlayer()))])§
Card: Nat Pagle NAME_END 0 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END At the start of your turn, you have a 50% chance to draw an extra card.

Python implementation:
class NatPagle(MinionCard):§    def __init__(self):§        super().__init__("Nat Pagle", 2, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(0, 4, effects=[Effect(TurnStarted(), ActionTag(Draw(), PlayerSelector(), OneIn(2)))])§
Card: Naturalize NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END Destroy a minion. Your opponent draws 2 cards.

Python implementation:
class Naturalize(SpellCard):§    def __init__(self):§        super().__init__("Naturalize", 1, CHARACTER_CLASS.DRUID, 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.other_player.draw()§        game.other_player.draw()§
Card: Nightmare NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Dream PLAYER_CLS_END NIL RACE_END NIL RARITY_END Give a minion +5/+5. At the start of your next turn, destroy it.

Python implementation:
class Nightmare(SpellCard):§    def __init__(self):§        super().__init__("Nightmare", 0, CHARACTER_CLASS.DREAM, CARD_RARITY.COMMON, False, hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.add_buff(Buff(ChangeAttack(5)))§        self.target.add_buff(Buff(ChangeHealth(5)))§        self.target.add_effect(Effect(TurnStarted(player=CurrentPlayer()), ActionTag(Kill(), SelfSelector())))§
Card: Nozdormu NAME_END 8 ATK_END 8 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Legendary RARITY_END Players only have 15 seconds to take their turns.

Python implementation:
class Nozdormu(MinionCard):§    def __init__(self):§        super().__init__("Nozdormu", 9, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        return Minion(8, 8)§
Card: Onyxia NAME_END 8 ATK_END 8 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Legendary RARITY_END <b>Battlecry:</b> Summon 1/1 Whelps until your side of the battlefield is full.

Python implementation:
class Onyxia(MinionCard):§    def __init__(self):§        super().__init__("Onyxia", 9, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DRAGON, battlecry=Battlecry(Summon(Whelp(), 6), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(8, 8)§
Card: Panther NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Common RARITY_END NIL

Python implementation:
class Panther(MinionCard):§    def __init__(self):§        super().__init__("Panther", 2, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, False, MINION_TYPE.BEAST)§§    def create_minion(self, _):§        return Minion(3, 2, MINION_TYPE.BEAST)§
Card: Patient Assassin NAME_END 1 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Stealth</b>. Destroy any minion damaged by this minion.

Python implementation:
class PatientAssassin(MinionCard):§    def __init__(self):§        super().__init__("Patient Assassin", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(1, 1, stealth=True, effects=[Effect(DidDamage(), ActionTag(Kill(), TargetSelector(IsMinion())))])§
Card: Perdition's Blade NAME_END 2 ATK_END -1 DEF_END 3 COST_END 2 DUR_END Weapon TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Deal 1 damage. <b>Combo:</b> Deal 2 instead.

Python implementation:
class PerditionsBlade(WeaponCard):§    def __init__(self):§        super().__init__("Perdition's Blade", 3, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE, battlecry=Battlecry(Damage(1), CharacterSelector(None, picker=UserPicker())), combo=Battlecry(Damage(2), CharacterSelector(None, picker=UserPicker())))§§    def create_weapon(self, player):§        return Weapon(2, 2)§
Card: Pint-Sized Summoner NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END The first minion you play each turn costs (1) less.

Python implementation:
class PintSizedSummoner(MinionCard):§    def __init__(self):§        super().__init__("Pint-Sized Summoner", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(2, 2, effects=[Effect(TurnStarted(), ActionTag(GiveAura(AuraUntil(ManaChange(-1), CardSelector( condition=IsMinion()), MinionPlaced())), PlayerSelector()))])§
Card: Pit Lord NAME_END 5 ATK_END 6 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Epic RARITY_END <b>Battlecry:</b> Deal 5 damage to your hero.

Python implementation:
class PitLord(MinionCard):§    def __init__(self):§        super().__init__("Pit Lord", 4, CHARACTER_CLASS.WARLOCK, CARD_RARITY.EPIC, minion_type=MINION_TYPE.DEMON, battlecry=Battlecry(Damage(5), HeroSelector()))§§    def create_minion(self, player):§        return Minion(5, 6)§