dvitel/hearthstone huggingface dataset:
Card: Archmage NAME_END 4 ATK_END 7 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Spell Damage +1</b>

Python implementation:
class Archmage(MinionCard):§    def __init__(self):§        super().__init__("Archmage", 6, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 7, spell_damage=1)§
Card: Booty Bay Bodyguard NAME_END 5 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Taunt</b>

Python implementation:
class BootyBayBodyguard(MinionCard):§    def __init__(self):§        super().__init__("Booty Bay Bodyguard", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(5, 4, taunt=True)§
Card: Darkscale Healer NAME_END 4 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Restore 2 Health to all friendly characters.

Python implementation:
class DarkscaleHealer(MinionCard):§    def __init__(self):§        super().__init__("Darkscale Healer", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Heal(2), CharacterSelector()))§§    def create_minion(self, player):§        return Minion(4, 5)§
Card: Fiery War Axe NAME_END 3 ATK_END -1 DEF_END 2 COST_END 2 DUR_END Weapon TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Free RARITY_END NIL

Python implementation:
class FieryWarAxe(WeaponCard):§    def __init__(self):§        super().__init__("Fiery War Axe", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.FREE)§§    def create_weapon(self, player):§        return Weapon(3, 2)§
Card: Frostwolf Warlord NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Gain +1/+1 for each other friendly minion on the battlefield.

Python implementation:
class FrostwolfWarlord(MinionCard):§    def __init__(self):§        super().__init__("Frostwolf Warlord", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Give([Buff(ChangeAttack(Count(MinionSelector()))), Buff(ChangeHealth(Count(MinionSelector())))]), SelfSelector()))§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Hellfire NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $3 damage to ALL characters.

Python implementation:
class Hellfire(SpellCard):§    def __init__(self):§        super().__init__("Hellfire", 4, CHARACTER_CLASS.WARLOCK, CARD_RARITY.FREE)§§    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 minion in targets:§            minion.damage(player.effective_spell_damage(3), self)§
Card: Innervate NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Free RARITY_END Gain 2 Mana Crystals this turn only.

Python implementation:
class Innervate(SpellCard):§    def __init__(self):§        super().__init__("Innervate", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§        if player.mana < 8:§            player.mana += 2§        else:§            player.mana = 10§
Card: Magma Rager NAME_END 5 ATK_END 1 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Free RARITY_END NIL

Python implementation:
class MagmaRager(MinionCard):§    def __init__(self):§        super().__init__("Magma Rager", 3, CHARACTER_CLASS.ALL, CARD_RARITY.FREE)§§    def create_minion(self, player):§        return Minion(5, 1)§
Card: Mortal Coil NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $1 damage to a minion. If that kills it, draw a card.

Python implementation:
class MortalCoil(SpellCard):§    def __init__(self):§        super().__init__("Mortal Coil", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        if self.target.health <= player.effective_spell_damage(1) and not self.target.divine_shield:§            self.target.damage(player.effective_spell_damage(1), self)§            player.draw()§        else:§            self.target.damage(player.effective_spell_damage(1), self)§
Card: Polymorph NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Free RARITY_END Transform a minion into a 1/1 Sheep.

Python implementation:
class Polymorph(SpellCard):§    def __init__(self):§        super().__init__("Polymorph", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        from hearthbreaker.cards.minions.mage import Sheep§        sheep = Sheep()§        minion = sheep.create_minion(None)§        minion.card = sheep§        self.target.replace(minion)§
Card: Searing Totem NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END Totem RACE_END Free RARITY_END NIL

Python implementation:
class SearingTotem(MinionCard):§    def __init__(self):§        super().__init__("Searing Totem", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.FREE, False, MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Silverback Patriarch NAME_END 1 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Taunt</b>

Python implementation:
class SilverbackPatriarch(MinionCard):§    def __init__(self):§        super().__init__("Silverback Patriarch", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 4, taunt=True)§
Card: Stormwind Knight NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Charge</b>

Python implementation:
class StormwindKnight(MinionCard):§    def __init__(self):§        super().__init__("Stormwind Knight", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 5, charge=True)§
Card: Voodoo Doctor NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Free RARITY_END <b>Battlecry:</b> Restore 2 Health.

Python implementation:
class VoodooDoctor(MinionCard):§    def __init__(self):§        super().__init__("Voodoo Doctor", 1, CHARACTER_CLASS.ALL, CARD_RARITY.FREE, battlecry=Battlecry(Heal(2), CharacterSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 1)§
Card: Wrath of Air Totem NAME_END 0 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END Totem RACE_END Free RARITY_END <b>Spell Damage +1</b>

Python implementation:
class WrathOfAirTotem(MinionCard):§    def __init__(self):§        super().__init__("Wrath of Air Totem", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.FREE, False, MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(0, 2, spell_damage=1)§
Card: Astral Communion NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END Gain 10 Mana Crystals. Discard your hand.

Python implementation:
class AstralCommunion(SpellCard):§    def __init__(self):§        super().__init__("Astral Communion", 4, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§        for card in player.hand:§            card.unattach()§            player.trigger("card_discarded", card)§        player.hand = []§        player.max_mana = 10§        player.mana = 10§
Card: Annoy-o-Tron 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 <b>Taunt</b> NL <b>Divine Shield</b>

Python implementation:
class AnnoyoTron(MinionCard):§    def __init__(self):§        super().__init__("Annoy-o-Tron", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 2, divine_shield=True, taunt=True)§
Card: Burly Rockjaw Trogg NAME_END 3 ATK_END 5 DEF_END 4 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 +2 Attack.

Python implementation:
class BurlyRockjawTrogg(MinionCard):§    def __init__(self):§        super().__init__("Burly Rockjaw Trogg", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 5, effects=[Effect(SpellCast(player=EnemyPlayer()), ActionTag(Give(ChangeAttack(2)), SelfSelector()))])§
Card: Cogmaster's Wrench NAME_END 1 ATK_END -1 DEF_END 3 COST_END 3 DUR_END Weapon TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Epic RARITY_END Has +2 Attack while you have a Mech.

Python implementation:
class CogmastersWrench(WeaponCard):§    def __init__(self):§        super().__init__("Cogmaster's Wrench", 3, CHARACTER_CLASS.ROGUE, CARD_RARITY.EPIC)§§    def create_weapon(self, player):§        return Weapon(1, 3, buffs=[Buff(ChangeAttack(2), GreaterThan(Count(MinionSelector(IsType(MINION_TYPE.MECH))), value=0))])§
Card: Echo of Medivh NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Epic RARITY_END Put a copy of each friendly minion into your hand.

Python implementation:
class EchoOfMedivh(SpellCard):§    def __init__(self):§        super().__init__("Echo of Medivh", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§        for minion in sorted(copy.copy(player.minions), key=lambda minion: minion.born):§            if len(player.hand) < 10:§                player.hand.append(minion.card)§
Card: Floating Watcher NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Common RARITY_END Whenever your hero takes damage on your turn, gain +2/+2.

Python implementation:
class FloatingWatcher(MinionCard):§    def __init__(self):§        super().__init__("Floating Watcher", 5, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(4, 4, effects=[Effect(CharacterDamaged(And(IsHero(), OwnersTurn())), ActionTag(Give([Buff(ChangeAttack(2)), Buff(ChangeHealth(2))]), SelfSelector()))])§
Card: Gnomish Experimenter NAME_END 3 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Draw a card. If it's a minion, transform it into a Chicken.

Python implementation:
class GnomishExperimenter(MinionCard):§    def __init__(self):§        super().__init__("Gnomish Experimenter", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=(Battlecry(Draw(), PlayerSelector()), Battlecry(Transform(GnomishChicken()), LastDrawnSelector(), Matches(LastDrawnSelector(), IsMinion()))))§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Iron Juggernaut NAME_END 6 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END Mech RACE_END Legendary RARITY_END <b>Battlecry:</b> Shuffle a Mine into your opponent's deck. When drawn, it explodes for 10 damage.

Python implementation:
class IronJuggernaut(MinionCard):§    def __init__(self):§        super().__init__("Iron Juggernaut", 6, CHARACTER_CLASS.WARRIOR, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.MECH, battlecry=Battlecry(AddCard(BurrowingMine(), add_to_deck=True), PlayerSelector(EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(6, 5)§
Card: Madder Bomber NAME_END 5 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Deal 6 damage randomly split between all other characters.

Python implementation:
class MadderBomber(MinionCard):§    def __init__(self):§        super().__init__("Madder Bomber", 5, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(Damage(1), CharacterSelector(players=BothPlayer(), picker=RandomPicker(6))))§§    def create_minion(self, player):§        return Minion(5, 4)§
Card: Mini-Mage NAME_END 4 ATK_END 1 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Stealth</b> NL <b>Spell Damage +1</b>

Python implementation:
class MiniMage(MinionCard):§    def __init__(self):§        super().__init__("Mini-Mage", 4, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(4, 1, stealth=True, spell_damage=1)§
Card: Piloted Sky Golem NAME_END 6 ATK_END 4 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Epic RARITY_END <b>Deathrattle:</b> Summon a random 4-Cost minion.

Python implementation:
class PilotedSkyGolem(MinionCard):§    def __init__(self):§        super().__init__("Piloted Sky Golem", 6, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(6, 4, deathrattle=Deathrattle(Summon(CardQuery(conditions=[ManaCost(4), IsMinion()])), PlayerSelector()))§
Card: Scarlet Purifier NAME_END 4 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry</b>: Deal 2 damage to all minions with <b>Deathrattle</b>.

Python implementation:
class ScarletPurifier(MinionCard):§    def __init__(self):§        super().__init__("Scarlet Purifier", 3, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE, battlecry=Battlecry(Damage(2), MinionSelector(MinionHasDeathrattle(), BothPlayer())))§§    def create_minion(self, player):§        return Minion(4, 3)§
Card: Siltfin Spiritwalker NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END Murloc RACE_END Epic RARITY_END Whenever another friendly Murloc dies, draw a card. <b>Overload</b>: (1)

Python implementation:
class SiltfinSpiritwalker(MinionCard):§    def __init__(self):§        super().__init__("Siltfin Spiritwalker", 4, CHARACTER_CLASS.SHAMAN, CARD_RARITY.EPIC, minion_type=MINION_TYPE.MURLOC, overload=1)§§    def create_minion(self, player):§        return Minion(2, 5, effects=[Effect(MinionDied(IsType(MINION_TYPE.MURLOC)), ActionTag(Draw(), PlayerSelector()))])§
Card: Tinkertown Technician NAME_END 3 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>Battlecry:</b> If you have a Mech, gain +1/+1 and add a <b>Spare Part</b> to your hand.

Python implementation:
class TinkertownTechnician(MinionCard):§    def __init__(self):§        from hearthbreaker.cards.spells.neutral import spare_part_list§        super().__init__("Tinkertown Technician", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=(Battlecry(Give([Buff(ChangeAttack(1)), Buff(ChangeHealth(1))]), SelfSelector(), GreaterThan(Count(MinionSelector(IsType(MINION_TYPE.MECH))), value=0)), Battlecry(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=spare_part_list)), PlayerSelector(), GreaterThan(Count(MinionSelector(IsType(MINION_TYPE.MECH))), value=0))))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Vol'jin NAME_END 6 ATK_END 2 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Battlecry:</b> Swap Health with another minion.

Python implementation:
class Voljin(MinionCard):§    def __init__(self):§        super().__init__("Vol'jin", 5, CHARACTER_CLASS.PRIEST, CARD_RARITY.LEGENDARY, battlecry=Battlecry(SwapStats("health", "health", True), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(6, 2)§
Card: Death's Bite NAME_END 4 ATK_END -1 DEF_END 4 COST_END 2 DUR_END Weapon TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Deal 1 damage to all minions.

Python implementation:
class DeathsBite(WeaponCard):§    def __init__(self):§        super().__init__("Death's Bite", 4, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def create_weapon(self, player):§        return Weapon(4, 2, deathrattle=Deathrattle(Damage(1), MinionSelector(players=BothPlayer())))§
Card: Maexxna NAME_END 2 ATK_END 8 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Legendary RARITY_END Destroy any minion damaged by this minion.

Python implementation:
class Maexxna(MinionCard):§    def __init__(self):§        super().__init__("Maexxna", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(2, 8, effects=[Effect(DidDamage(), ActionTag(Kill(), TargetSelector(IsMinion())))])§
Card: Sludge Belcher NAME_END 3 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Taunt. NL Deathrattle:</b> Summon a 1/2 Slime with <b>Taunt</b>.

Python implementation:
class SludgeBelcher(MinionCard):§    def __init__(self):§        super().__init__("Sludge Belcher", 5, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(3, 5, taunt=True, deathrattle=Deathrattle(Summon(Slime()), PlayerSelector()))§
Card: Voidcaller NAME_END 3 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Common RARITY_END <b>Deathrattle:</b> Put a random Demon from your hand into the battlefield.

Python implementation:
class Voidcaller(MinionCard):§    def __init__(self):§        super().__init__("Voidcaller", 4, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(3, 4, deathrattle=Deathrattle(Summon(CardQuery(conditions=[IsType(MINION_TYPE.DEMON)], source=CARD_SOURCE.MY_HAND)), PlayerSelector()))§
Card: Alexstrasza 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> Set a hero's remaining Health to 15.

Python implementation:
class Alexstrasza(MinionCard):§    def __init__(self):§        super().__init__("Alexstrasza", 9, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DRAGON, battlecry=Battlecry(SetHealth(15), HeroSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(8, 8)§
Card: Arcane Golem NAME_END 4 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Charge</b>. <b>Battlecry:</b> Give your opponent a Mana Crystal.

Python implementation:
class ArcaneGolem(MinionCard):§    def __init__(self):§        super().__init__("Arcane Golem", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(GiveManaCrystal(), PlayerSelector(players=EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(4, 2, charge=True)§
Card: Baine Bloodhoof NAME_END 4 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Python implementation:
class BaineBloodhoof(MinionCard):§    def __init__(self):§        super().__init__("Baine Bloodhoof", 4, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, False)§§    def create_minion(self, player):§        return Minion(4, 5)§
Card: Blade Flurry NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Rare RARITY_END Destroy your weapon and deal its damage to all enemies.

Python implementation:
class BladeFlurry(SpellCard):§    def __init__(self):§        super().__init__("Blade Flurry", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§§        if player.weapon is not None:§            attack_power = player.effective_spell_damage(player.hero.calculate_attack())§            player.weapon.destroy()§§            for minion in copy.copy(game.other_player.minions):§                minion.damage(attack_power, self)§§            game.other_player.hero.damage(attack_power, self)§
Card: Brawl NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Epic RARITY_END Destroy all minions except one. <i>(chosen randomly)</i>

Python implementation:
class Brawl(SpellCard):§    def __init__(self):§        super().__init__("Brawl", 5, CHARACTER_CLASS.WARRIOR, CARD_RARITY.EPIC)§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(player.minions) + len(player.opponent.minions) >= 2§§    def use(self, player, game):§        super().use(player, game)§§        minions = copy.copy(player.minions)§        minions.extend(game.other_player.minions)§§        if len(minions) > 1:§            survivor = game.random_choice(minions)§            for minion in minions:§                if minion is not survivor:§                    minion.die(self)§
Card: Conceal NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Give your minions <b>Stealth</b> until your next turn.

Python implementation:
class Conceal(SpellCard):§    def __init__(self):§        super().__init__("Conceal", 1, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        for minion in player.minions:§            if not minion.stealth:§                minion.add_buff(BuffUntil(Stealth(), TurnStarted()))§
Card: Defender NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END NIL

Python implementation:
class DefenderMinion(MinionCard):§    def __init__(self):§        super().__init__("Defender", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON)§§    def create_minion(self, p):§        return Minion(2, 1)§
Card: Doomguard NAME_END 5 ATK_END 7 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Rare RARITY_END <b>Charge</b>. <b>Battlecry:</b> Discard two random cards.

Python implementation:
class Doomguard(MinionCard):§    def __init__(self):§        super().__init__("Doomguard", 5, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, minion_type=MINION_TYPE.DEMON, battlecry=Battlecry(Discard(amount=2), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(5, 7, charge=True)§
Card: Earth Elemental NAME_END 7 ATK_END 8 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Taunt</b>. <b>Overload:</b> (3)

Python implementation:
class EarthElemental(MinionCard):§    def __init__(self):§        super().__init__("Earth Elemental", 5, CHARACTER_CLASS.SHAMAN, CARD_RARITY.EPIC, overload=3)§§    def create_minion(self, player):§        return Minion(7, 8, taunt=True)§
Card: Explosive Trap NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Secret:</b> When your hero is attacked, deal $2 damage to all enemies.

Python implementation:
class ExplosiveTrap(SecretCard):§    def __init__(self):§        super().__init__("Explosive Trap", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON)§§    def activate(self, player):§        player.opponent.bind("character_attack", self._reveal)§§    def deactivate(self, player):§        player.opponent.unbind("character_attack", self._reveal)§§    def _reveal(self, attacker, target):§        if isinstance(target, Hero):§            game = attacker.player.game§            enemies = copy.copy(game.current_player.minions)§            enemies.append(game.current_player.hero)§            for enemy in enemies:§                enemy.damage(2, None)§            game.check_delayed()§            super().reveal()§