dvitel/hearthstone huggingface dataset:
Card: Sword of Justice NAME_END 1 ATK_END -1 DEF_END 3 COST_END 5 DUR_END Weapon TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Epic RARITY_END Whenever you summon a minion, give it +1/+1 and this loses 1 Durability.

Python implementation:
class SwordOfJustice(WeaponCard):§    def __init__(self):§        super().__init__("Sword of Justice", 3, CHARACTER_CLASS.PALADIN, CARD_RARITY.EPIC)§§    def create_weapon(self, player):§        return Weapon(1, 5, effects=[Effect(MinionSummoned(), ActionTag(Give([Buff(ChangeAttack(1)), Buff(ChangeHealth(1))]), TargetSelector())), Effect(MinionSummoned(), ActionTag(DecreaseDurability(), WeaponSelector()))])§
Card: Sylvanas Windrunner NAME_END 5 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Deathrattle:</b> Take control of a random enemy minion.

Python implementation:
class SylvanasWindrunner(MinionCard):§    def __init__(self):§        super().__init__("Sylvanas Windrunner", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(5, 5, deathrattle=Deathrattle(Steal(), MinionSelector(players=EnemyPlayer(), picker=RandomPicker())))§
Card: Tauren Warrior NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Taunt</b>. <b>Enrage:</b> +3 Attack

Python implementation:
class TaurenWarrior(MinionCard):§    def __init__(self):§        super().__init__("Tauren Warrior", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, taunt=True, enrage=[Aura(ChangeAttack(3), SelfSelector())])§
Card: Temple Enforcer NAME_END 6 ATK_END 6 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Give a friendly minion +3 Health.

Python implementation:
class TempleEnforcer(MinionCard):§    def __init__(self):§        super().__init__("Temple Enforcer", 6, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON, battlecry=Battlecry(Give(ChangeHealth(3)), MinionSelector(picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(6, 6)§
Card: The Beast NAME_END 9 ATK_END 7 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Legendary RARITY_END <b>Deathrattle:</b> Summon a 3/3 Finkle Einhorn for your opponent.

Python implementation:
class TheBeast(MinionCard):§    def __init__(self):§        super().__init__("The Beast", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(9, 7, deathrattle=Deathrattle(Summon(FinkleEinhorn()), PlayerSelector(EnemyPlayer())))§
Card: The Black Knight NAME_END 4 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Battlecry:</b> Destroy an enemy minion with <b>Taunt</b>.

Python implementation:
class TheBlackKnight(MinionCard):§    def __init__(self):§        super().__init__("The Black Knight", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, battlecry=Battlecry(Kill(), MinionSelector(HasStatus("taunt"), EnemyPlayer(), UserPicker())))§§    def create_minion(self, player):§        return Minion(4, 5)§
Card: Thoughtsteal 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 Copy 2 cards from your opponent's deck and put them into your hand.

Python implementation:
class Thoughtsteal(SpellCard):§    def __init__(self):§        super().__init__("Thoughtsteal", 3, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        for i in range(0, 2):§            new_card = game.random_draw(game.other_player.deck.cards, lambda c: not c.drawn)§            if new_card:§                new_card = copy.copy(new_card)§                new_card.drawn = True§                if len(player.hand) < 10:§                    player.hand.append(new_card)§                    new_card.player = player§                    self.trigger("card_drawn", new_card)§                else:§                    player.trigger("card_destroyed", new_card)§
Card: Tirion Fordring NAME_END 6 ATK_END 6 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Divine Shield</b>. <b>Taunt</b>. <b>Deathrattle:</b> Equip a 5/3 Ashbringer.

Python implementation:
class TirionFordring(MinionCard):§    def __init__(self):§        super().__init__("Tirion Fordring", 8, CHARACTER_CLASS.PALADIN, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(6, 6, divine_shield=True, taunt=True, deathrattle=Deathrattle(Equip(Ashbringer()), PlayerSelector()))§
Card: Treant NAME_END 2 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Charge</b>. At the end of the turn, destroy this minion.

Python implementation:
class Treant(MinionCard):§    def __init__(self):§        super().__init__("Treant", 1, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON)§§    def create_minion(self, _):§        return Minion(2, 2)§
Card: Treant NAME_END 2 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END NIL RARITY_END <b>Taunt</b>

Python implementation:
class Treant(MinionCard):§    def __init__(self):§        super().__init__("Treant", 1, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON)§§    def create_minion(self, _):§        return Minion(2, 2)§
Card: Twilight Drake NAME_END 4 ATK_END 1 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Rare RARITY_END <b>Battlecry:</b> Gain +1 Health for each card in your hand.

Python implementation:
class TwilightDrake(MinionCard):§    def __init__(self):§        super().__init__("Twilight Drake", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.DRAGON, battlecry=Battlecry(Give(Buff(ChangeHealth(Count(CardSelector())))), SelfSelector()))§§    def create_minion(self, player):§        return Minion(4, 1)§
Card: Twisting Nether NAME_END -1 ATK_END -1 DEF_END 8 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Epic RARITY_END Destroy all minions.

Python implementation:
class TwistingNether(SpellCard):§    def __init__(self):§        super().__init__("Twisting Nether", 8, CHARACTER_CLASS.WARLOCK, 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)§        for minion in targets:§            minion.die(self)§
Card: Unbound Elemental NAME_END 2 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever you play a card with <b>Overload</b>, gain +1/+1.

Python implementation:
class UnboundElemental(MinionCard):§    def __init__(self):§        super().__init__("Unbound Elemental", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 4, effects=[Effect(CardPlayed(HasOverload()), ActionTag(Give(ChangeAttack(1)), SelfSelector())), Effect(CardPlayed(HasOverload()), ActionTag(Give(ChangeHealth(1)), SelfSelector()))])§
Card: Unleash the Hounds NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Common RARITY_END For each enemy minion, summon a 1/1 Hound with <b>Charge</b>.

Python implementation:
class UnleashTheHounds(SpellCard):§    def __init__(self):§        super().__init__("Unleash the Hounds", 3, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        for target in hearthbreaker.targeting.find_enemy_minion_spell_target(player.game, lambda x: True):§            hound = hearthbreaker.cards.minions.hunter.Hound()§            hound.summon(player, game, len(player.minions))§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) >= 1 and len(player.minions) < 7§
Card: Venture Co. Mercenary NAME_END 7 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Your minions cost (3) more.

Python implementation:
class VentureCoMercenary(MinionCard):§    def __init__(self):§        super().__init__("Venture Co. Mercenary", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(7, 6, auras=[Aura(ManaChange(3), CardSelector(condition=IsMinion()))])§
Card: Violet Apprentice NAME_END 1 ATK_END 1 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class VioletApprentice(MinionCard):§    def __init__(self):§        super().__init__("Violet Apprentice", 0, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Violet Teacher 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 Whenever you cast a spell, summon a 1/1 Violet Apprentice.

Python implementation:
class VioletTeacher(MinionCard):§    def __init__(self):§        super().__init__("Violet Teacher", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(3, 5, effects=[Effect(SpellCast(), ActionTag(Summon(VioletApprentice()), PlayerSelector()))])§
Card: Void Terror NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Rare RARITY_END <b>Battlecry:</b> Destroy the minions on either side of this minion and gain their Attack and Health.

Python implementation:
class VoidTerror(MinionCard):§    def __init__(self):§        super().__init__("Void Terror", 3, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, minion_type=MINION_TYPE.DEMON, battlecry=(Battlecry( Give([Buff(ChangeHealth(Attribute("health", MinionSelector(Adjacent())))), Buff(ChangeAttack(Attribute("attack", MinionSelector(Adjacent()))))]), SelfSelector()), Battlecry(Kill(), MinionSelector(Adjacent()))))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Whelp NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END NIL RARITY_END NIL

Python implementation:
class Whelp(MinionCard):§    def __init__(self):§        super().__init__("Whelp", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Wild Pyromancer NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END After you cast a spell, deal 1 damage to ALL minions.

Python implementation:
class WildPyromancer(MinionCard):§    def __init__(self):§        super().__init__("Wild Pyromancer", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(3, 2, effects=[Effect(CardUsed(IsSpell()), ActionTag(Damage(1), MinionSelector(condition=None, players=BothPlayer())))])§
Card: Windfury Harpy NAME_END 4 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Windfury</b>

Python implementation:
class WindfuryHarpy(MinionCard):§    def __init__(self):§        super().__init__("Windfury Harpy", 6, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 5, windfury=True)§
Card: Worthless Imp NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Common RARITY_END <i>You are out of demons! At least there are always imps...</i>

Python implementation:
class WorthlessImp(MinionCard):§    def __init__(self):§        super().__init__("Worthless Imp", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, False, MINION_TYPE.DEMON)§§    def create_minion(self, p):§        return Minion(1, 1)§
Card: Wrath NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Choose One</b> - Deal $3 damage to a minion; or $1 damage and draw a card.

Python implementation:
class Wrath(SpellCard):§    def __init__(self):§        super().__init__("Wrath", 2, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        class WrathOne(ChoiceCard):§            def __init__(self):§                super().__init__("Wrath 1 Damage", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§            def use(self, player, game):§                target.damage(player.effective_spell_damage(1), wrath)§                player.draw()§§        class WrathThree(ChoiceCard):§            def __init__(self):§                super().__init__("Wrath 3 Damage", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§            def use(self, player, game):§                target.damage(player.effective_spell_damage(3), wrath)§§        super().use(player, game)§        option = game.current_player.agent.choose_option([WrathOne(), WrathThree()], player)§        target = self.target§        wrath = self§        option.use(player, game)§
Card: Young Dragonhawk NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Windfury</b>

Python implementation:
class YoungDragonhawk(MinionCard):§    def __init__(self):§        super().__init__("Young Dragonhawk", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1, windfury=True)§
Card: Young Priestess NAME_END 2 ATK_END 1 DEF_END 1 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 Health.

Python implementation:
class YoungPriestess(MinionCard):§    def __init__(self):§        super().__init__("Young Priestess", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(2, 1, effects=[Effect(TurnEnded(), ActionTag(Give(ChangeHealth(1)), MinionSelector(picker=RandomPicker())))])§
Card: Youthful Brewmaster 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> Return a friendly minion from the battlefield to your hand.

Python implementation:
class YouthfulBrewmaster(MinionCard):§    def __init__(self):§        super().__init__("Youthful Brewmaster", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Bounce(), MinionSelector(picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Ysera 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 At the end of your turn, add a Dream Card to your hand.

Python implementation:
class Ysera(MinionCard):§    def __init__(self):§        super().__init__("Ysera", 9, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        dream_card_list = [EmeraldDrake(), LaughingSister(), Nightmare(), YseraAwakens(), Dream()]§        return Minion(4, 12, effects=[Effect(TurnEnded(), ActionTag(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=dream_card_list)), PlayerSelector()))])§
Card: Ysera Awakens NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Dream PLAYER_CLS_END NIL RACE_END NIL RARITY_END Deal $5 damage to all characters except Ysera.

Python implementation:
class YseraAwakens(SpellCard):§    def __init__(self):§        super().__init__("Ysera Awakens", 2, CHARACTER_CLASS.DREAM, CARD_RARITY.COMMON, False)§§    def use(self, player, game):§        super().use(player, game)§        targets = copy.copy(player.game.other_player.minions)§        targets.extend(player.game.current_player.minions)§        targets.append(player.game.other_player.hero)§        targets.append(player.game.current_player.hero)§        targets = filter(lambda m: not m.is_minion() or m.card.name != "Ysera", targets)§        for minion in targets:§            minion.damage(player.effective_spell_damage(5), self)§
Card: Axe Flinger NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever this minion takes damage, deal 2 damage to the enemy hero.

Python implementation:
class AxeFlinger(MinionCard):§    def __init__(self):§        super().__init__("Axe Flinger", 4, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 5, effects=[Effect(Damaged(), ActionTag(Damage(2), HeroSelector(EnemyPlayer())))])§
Card: Blackwing Technician NAME_END 2 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>Battlecry:</b> If you're holding a Dragon, gain +1/+1.

Python implementation:
class BlackwingTechnician(MinionCard):§    def __init__(self):§        super().__init__("Blackwing Technician", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=(Battlecry(Give([Buff(ChangeAttack(1)), Buff(ChangeHealth(1))]), SelfSelector(), GreaterThan(Count(CardSelector(condition=IsType(MINION_TYPE.DRAGON))), value=0))))§§    def create_minion(self, player):§        return Minion(2, 4)§
Card: Chromaggus NAME_END 6 ATK_END 8 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Legendary RARITY_END Whenever you draw a card, put another copy into your hand.

Python implementation:
class Chromaggus(MinionCard):§    def __init__(self):§        super().__init__("Chromaggus", 8, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        return Minion(6, 8, effects=[Effect(CardDrawn(), [ActionTag(AddCard(CardQuery(source=CARD_SOURCE.LAST_DRAWN, make_copy=True)), PlayerSelector())])])§
Card: Core Rager NAME_END 4 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Rare RARITY_END <b>Battlecry:</b> If your hand is empty, gain +3/+3.

Python implementation:
class CoreRager(MinionCard):§    def __init__(self):§        super().__init__("Core Rager", 4, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST, battlecry=(Battlecry(Give([Buff(ChangeAttack(3)), Buff(ChangeHealth(3))]), SelfSelector(), Not(GreaterThan(Count(CardSelector()), value=0)))))§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Dark Iron Skulker NAME_END 4 ATK_END 3 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Deal 2 damage to all undamaged enemy minions.

Python implementation:
class DarkIronSkulker(MinionCard):§    def __init__(self):§        super().__init__("Dark Iron Skulker", 5, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE, battlecry=Battlecry(Damage(2), MinionSelector(condition=Not(IsDamaged()), players=EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(4, 3)§
Card: Demonwrath NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $2 damage to all non-Demon minions.

Python implementation:
class Demonwrath(SpellCard):§    def __init__(self):§        super().__init__("Demonwrath", 3, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        targets = copy.copy(game.other_player.minions)§        targets.extend(game.current_player.minions)§        for minion in targets:§            if minion.card.minion_type is not MINION_TYPE.DEMON:§                minion.damage(player.effective_spell_damage(2), self)§
Card: Dragon Consort NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END Dragon RACE_END Rare RARITY_END <b>Battlecry:</b> The next Dragon you play costs (2) less.

Python implementation:
class DragonConsort(MinionCard):§    def __init__(self):§        super().__init__("Dragon Consort", 5, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE, minion_type=MINION_TYPE.DRAGON, battlecry=Battlecry(GiveAura([AuraUntil(ManaChange(-3), CardSelector(condition=IsType(MINION_TYPE.DRAGON)), CardPlayed(IsType(MINION_TYPE.DRAGON)), False)]), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: Dragon Egg NAME_END 0 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever this minion takes damage, summon a 2/1 Whelp.

Python implementation:
class DragonEgg(MinionCard):§    def __init__(self):§        super().__init__("Dragon Egg", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(0, 2, effects=[Effect(Damaged(), ActionTag(Summon(BlackWhelp()), PlayerSelector()))])§
Card: Dragon's Breath NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $4 damage. Costs (1) less for each minion that died this turn.

Python implementation:
class DragonsBreath(SpellCard):§    def __init__(self):§        super().__init__("Dragon's Breath", 5, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_spell_target, buffs=[Buff(ManaChange(Count(DeadMinionSelector(players=BothPlayer())), -1))])§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(player.effective_spell_damage(4), self)§
Card: Druid of the Flame NAME_END 5 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Common RARITY_END NIL

Python implementation:
class DruidOfTheFlame(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Flame", 3, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(FlameCatForm(), Transform(FlameCat()), SelfSelector()),§            Choice(FlameBirdForm(), Transform(FlameBird()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Druid of the Flame NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Choose One</b> - Transform into a 5/2 minion; or a 2/5 minion.

Python implementation:
class DruidOfTheFlame(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Flame", 3, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(FlameCatForm(), Transform(FlameCat()), SelfSelector()),§            Choice(FlameBirdForm(), Transform(FlameBird()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Druid of the Flame NAME_END 2 ATK_END 5 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Common RARITY_END NIL

Python implementation:
class DruidOfTheFlame(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Flame", 3, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(FlameCatForm(), Transform(FlameCat()), SelfSelector()),§            Choice(FlameBirdForm(), Transform(FlameBird()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Emperor Thaurissan NAME_END 5 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END At the end of your turn, reduce the Cost of cards in your hand by (1).

Python implementation:
class EmperorThaurissan(MinionCard):§    def __init__(self):§        super().__init__("Emperor Thaurissan", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(5, 5, effects=[Effect(TurnEnded(), [ActionTag(Give(Buff(ManaChange(-1))), CardSelector())])])§