dvitel/hearthstone huggingface dataset:
Card: Acidic Swamp Ooze 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> Destroy your opponent's weapon.

Python implementation:
class AcidicSwampOoze(MinionCard):§    def __init__(self):§        super().__init__("Acidic Swamp Ooze", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Destroy(), WeaponSelector(EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Ancestral Healing NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Free RARITY_END Restore a minion to full Health and give it <b>Taunt</b>.

Python implementation:
class AncestralHealing(SpellCard):§    def __init__(self):§        super().__init__("Ancestral Healing", 0, CHARACTER_CLASS.SHAMAN, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.heal(player.effective_heal_power(self.target.calculate_max_health()), self)§        self.target.taunt = True§
Card: Animal Companion 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 Summon a random Beast Companion.

Python implementation:
class AnimalCompanion(SpellCard):§    def __init__(self):§        super().__init__("Animal Companion", 3, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        beast_list = [hearthbreaker.cards.minions.hunter.Huffer(), hearthbreaker.cards.minions.hunter.Misha(), hearthbreaker.cards.minions.hunter.Leokk()]§        card = game.random_choice(beast_list)§        card.summon(player, player.game, len(player.minions))§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(player.minions) < 7§
Card: Arcane Explosion NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $1 damage to all enemy minions.

Python implementation:
class ArcaneExplosion(SpellCard):§    def __init__(self):§        super().__init__("Arcane Explosion", 2, CHARACTER_CLASS.MAGE, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§        for minion in copy.copy(game.other_player.minions):§            minion.damage(player.effective_spell_damage(1), self)§
Card: Arcane Intellect NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Free RARITY_END Draw 2 cards.

Python implementation:
class ArcaneIntellect(SpellCard):§    def __init__(self):§        super().__init__("Arcane Intellect", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§        for c in range(0, 2):§            player.draw()§
Card: Arcane Missiles NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $3 damage randomly split among all enemies.

Python implementation:
class ArcaneMissiles(SpellCard):§    def __init__(self):§        super().__init__("Arcane Missiles", 1, CHARACTER_CLASS.MAGE, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§        for i in range(0, player.effective_spell_damage(3)):§            targets = copy.copy(game.other_player.minions)§            targets.append(game.other_player.hero)§            target = game.random_choice(targets)§            target.damage(1, self)§
Card: Arcane Shot NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $2 damage.

Python implementation:
class ArcaneShot(SpellCard):§    def __init__(self):§        super().__init__("Arcane Shot", 1, CHARACTER_CLASS.HUNTER, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(player.effective_spell_damage(2), self)§
Card: Arcanite Reaper NAME_END 5 ATK_END -1 DEF_END 5 COST_END 2 DUR_END Weapon TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END NIL

Python implementation:
class ArcaniteReaper(WeaponCard):§    def __init__(self):§        super().__init__("Arcanite Reaper", 5, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def create_weapon(self, player):§        return Weapon(5, 2)§
Card: Assassinate NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Free RARITY_END Destroy an enemy minion.

Python implementation:
class Assassinate(SpellCard):§    def __init__(self):§        super().__init__("Assassinate", 5, CHARACTER_CLASS.ROGUE, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_enemy_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.die(self)§
Card: Backstab NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $2 damage to an undamaged minion.

Python implementation:
class Backstab(SpellCard):§    def __init__(self):§        super().__init__("Backstab", 0, CHARACTER_CLASS.ROGUE, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_minion_spell_target, filter_func=lambda target: target.health == target.calculate_max_health() and target.spell_targetable())§§    def use(self, player, game):§        super().use(player, game)§§        self.target.damage(player.effective_spell_damage(2), self)§
Card: Blessing of Kings NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END Give a minion +4/+4. <i>(+4 Attack/+4 Health)</i>

Python implementation:
class BlessingOfKings(SpellCard):§    def __init__(self):§        super().__init__("Blessing of Kings", 4, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.change_attack(4)§        self.target.increase_health(4)§
Card: Blessing of Might NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Free RARITY_END Give a minion +3 Attack.

Python implementation:
class BlessingOfMight(SpellCard):§    def __init__(self):§        super().__init__("Blessing of Might", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.change_attack(3)§
Card: Bloodfen Raptor NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Free RARITY_END NIL

Python implementation:
class BloodfenRaptor(MinionCard):§    def __init__(self):§        super().__init__("Bloodfen Raptor", 2, CHARACTER_CLASS.ALL, CARD_RARITY.FREE, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(3, 2)§
Card: Bloodlust NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Give your minions +3 Attack this turn.

Python implementation:
class Bloodlust(SpellCard):§    def __init__(self):§        super().__init__("Bloodlust", 5, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        for minion in player.minions:§            minion.change_temp_attack(3)§
Card: Bluegill Warrior NAME_END 2 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Common RARITY_END <b>Charge</b>

Python implementation:
class BluegillWarrior(MinionCard):§    def __init__(self):§        super().__init__("Bluegill Warrior", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MURLOC)§§    def create_minion(self, player):§        return Minion(2, 1, charge=True)§
Card: Boar 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 NIL

Python implementation:
class Boar(MinionCard):§    def __init__(self):§        super().__init__("Boar", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Charge NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Free RARITY_END Give a friendly minion +2 Attack and <b>Charge</b>.

Python implementation:
class Charge(SpellCard):§    def __init__(self):§        super().__init__("Charge", 3, CHARACTER_CLASS.WARRIOR, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_friendly_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.change_attack(2)§        self.target.add_buff(Buff(_Charge()))§
Card: Chillwind Yeti NAME_END 4 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END NIL

Python implementation:
class ChillwindYeti(MinionCard):§    def __init__(self):§        super().__init__("Chillwind Yeti", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 5)§
Card: Claw NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Free RARITY_END Give your hero +2 Attack this turn and 2 Armor.

Python implementation:
class Claw(SpellCard):§    def __init__(self):§        super().__init__("Claw", 1, CHARACTER_CLASS.DRUID, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§        player.hero.change_temp_attack(2)§        player.hero.increase_armor(2)§
Card: Cleave NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $2 damage to two random enemy minions.

Python implementation:
class Cleave(SpellCard):§    def __init__(self):§        super().__init__("Cleave", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        minions = copy.copy(game.other_player.minions)§§        for i in range(0, 2):§            minion = game.random_choice(minions)§            minions.remove(minion)§            minion.damage(player.effective_spell_damage(2), self)§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) >= 2§
Card: Consecration NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $2 damage to all enemies.

Python implementation:
class Consecration(SpellCard):§    def __init__(self):§        super().__init__("Consecration", 4, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        for minion in copy.copy(game.other_player.minions):§            minion.damage(player.effective_spell_damage(2), self)§        game.other_player.hero.damage(player.effective_spell_damage(2), self)§
Card: Core Hound NAME_END 9 ATK_END 5 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END NIL

Python implementation:
class CoreHound(MinionCard):§    def __init__(self):§        super().__init__("Core Hound", 7, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(9, 5)§
Card: Corruption 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 Choose an enemy minion. At the start of your turn, destroy it.

Python implementation:
class Corruption(SpellCard):§    def __init__(self):§        super().__init__("Corruption", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_enemy_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.add_effect(Effect(TurnStarted(player=EnemyPlayer()), ActionTag(Kill(), SelfSelector())))§
Card: Dalaran Mage NAME_END 1 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>Spell Damage +1</b>

Python implementation:
class DalaranMage(MinionCard):§    def __init__(self):§        super().__init__("Dalaran Mage", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 4, spell_damage=1)§
Card: Divine Spirit NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END Double a minion's Health.

Python implementation:
class DivineSpirit(SpellCard):§    def __init__(self):§        super().__init__("Divine Spirit", 2, 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.increase_health(self.target.health)§
Card: Dragonling Mechanic NAME_END 2 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Summon a 2/1 Mechanical Dragonling.

Python implementation:
class DragonlingMechanic(MinionCard):§    def __init__(self):§        super().__init__("Dragonling Mechanic", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Summon(MechanicalDragonling()), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(2, 4)§
Card: Drain Life NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $2 damage. Restore #2 Health to your hero.

Python implementation:
class DrainLife(SpellCard):§    def __init__(self):§        super().__init__("Drain Life", 3, CHARACTER_CLASS.WARLOCK, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(player.effective_spell_damage(2), self)§        player.hero.heal(player.effective_heal_power(2), self)§
Card: Dread Infernal NAME_END 6 ATK_END 6 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Common RARITY_END <b>Battlecry:</b> Deal 1 damage to ALL other characters.

Python implementation:
class DreadInfernal(MinionCard):§    def __init__(self):§        super().__init__("Dread Infernal", 6, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DEMON, battlecry=Battlecry(Damage(1), CharacterSelector(players=BothPlayer())))§§    def create_minion(self, player):§        return Minion(6, 6)§
Card: Elven Archer NAME_END 1 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>Battlecry:</b> Deal 1 damage.

Python implementation:
class ElvenArcher(MinionCard):§    def __init__(self):§        super().__init__("Elven Archer", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Damage(1), CharacterSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Excess Mana NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END NIL RARITY_END Draw a card. <i>(You can only have 10 Mana in your tray.)</i>

Python implementation:
class ExcessMana(SpellCard):§    def __init__(self):§        super().__init__("Excess Mana", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, False)§§    def use(self, player, game):§        super().use(player, game)§        player.draw()§
Card: Execute NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Free RARITY_END Destroy a damaged enemy minion.

Python implementation:
class Execute(SpellCard):§    def __init__(self):§        super().__init__("Execute", 1, CHARACTER_CLASS.WARRIOR, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_enemy_minion_spell_target, filter_func=lambda target: target.health != target.calculate_max_health() and target.spell_targetable())§§    def use(self, player, game):§        super().use(player, game)§§        self.target.die(self)§
Card: Fan of Knives NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $1 damage to all enemy minions. Draw a card.

Python implementation:
class FanOfKnives(SpellCard):§    def __init__(self):§        super().__init__("Fan of Knives", 3, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        for minion in copy.copy(game.other_player.minions):§            minion.damage(player.effective_spell_damage(1), self)§§        player.draw()§
Card: Fireball 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 Deal $6 damage.

Python implementation:
class Fireball(SpellCard):§    def __init__(self):§        super().__init__("Fireball", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(player.effective_spell_damage(6), self)§
Card: Flamestrike NAME_END -1 ATK_END -1 DEF_END 7 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $4 damage to all enemy minions.

Python implementation:
class Flamestrike(SpellCard):§    def __init__(self):§        super().__init__("Flamestrike", 7, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        for minion in copy.copy(game.other_player.minions):§            minion.damage(player.effective_spell_damage(4), self)§
Card: Flametongue 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 Common RARITY_END Adjacent minions have +2 Attack.

Python implementation:
class FlametongueTotem(MinionCard):§    def __init__(self):§        super().__init__("Flametongue Totem", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, minion_type=MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(0, 3, auras=[Aura(ChangeAttack(2), MinionSelector(Adjacent()))])§
Card: Frog NAME_END 0 ATK_END 1 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Taunt</b>

Python implementation:
class Frog(MinionCard):§    def __init__(self):§        super().__init__("Frog", 0, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, p):§        return Minion(0, 1, taunt=True)§
Card: Frost Nova 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>Freeze</b> all enemy minions.

Python implementation:
class FrostNova(SpellCard):§    def __init__(self):§        super().__init__("Frost Nova", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        for minion in game.other_player.minions:§            minion.add_buff(Buff(Frozen()))§
Card: Frost Shock NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $1 damage to an enemy character and <b>Freeze</b> it.

Python implementation:
class FrostShock(SpellCard):§    def __init__(self):§        super().__init__("Frost Shock", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_enemy_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.damage(player.effective_spell_damage(1), self)§        self.target.add_buff(Buff(Frozen()))§
Card: Frostbolt NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $3 damage to a character and <b>Freeze</b> it.

Python implementation:
class Frostbolt(SpellCard):§    def __init__(self):§        super().__init__("Frostbolt", 2, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(player.effective_spell_damage(3), self)§        self.target.add_buff(Buff(Frozen()))§
Card: Frostwolf Grunt 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>Taunt</b>

Python implementation:
class FrostwolfGrunt(MinionCard):§    def __init__(self):§        super().__init__("Frostwolf Grunt", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 2, taunt=True)§
Card: Goldshire Footman NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Taunt</b>

Python implementation:
class GoldshireFootman(MinionCard):§    def __init__(self):§        super().__init__("Goldshire Footman", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 2, taunt=True)§
Card: Grimscale Oracle NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Common RARITY_END ALL other Murlocs have +1 Attack.

Python implementation:
class GrimscaleOracle(MinionCard):§    def __init__(self):§        super().__init__("Grimscale Oracle", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MURLOC)§§    def create_minion(self, player):§        return Minion(1, 1, auras=[Aura(ChangeAttack(1), MinionSelector(IsType(MINION_TYPE.MURLOC), BothPlayer()))])§
Card: Guardian of Kings NAME_END 5 ATK_END 6 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Restore 6 Health to your hero.

Python implementation:
class GuardianOfKings(MinionCard):§    def __init__(self):§        super().__init__("Guardian of Kings", 7, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON, battlecry=Battlecry(Heal(6), HeroSelector()))§§    def create_minion(self, player):§        return Minion(5, 6)§
Card: Gurubashi Berserker NAME_END 2 ATK_END 7 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever this minion takes damage, gain +3 Attack.

Python implementation:
class GurubashiBerserker(MinionCard):§    def __init__(self):§        super().__init__("Gurubashi Berserker", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 7, effects=[§            Effect(CharacterDamaged(condition=MinionIsTarget()), ActionTag(Give(ChangeAttack(3)), SelfSelector()))])§
Card: Hammer of Wrath NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Free RARITY_END Deal $3 damage. NL Draw a card.

Python implementation:
class HammerOfWrath(SpellCard):§    def __init__(self):§        super().__init__("Hammer of Wrath", 4, CHARACTER_CLASS.PALADIN, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.damage(player.effective_spell_damage(3), self)§        player.draw()§
Card: Hand of Protection NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Free RARITY_END Give a minion <b>Divine Shield</b>.

Python implementation:
class HandOfProtection(SpellCard):§    def __init__(self):§        super().__init__("Hand of Protection", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.FREE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.divine_shield = True§