dvitel/hearthstone huggingface dataset:
Card: Shield Block NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END Gain 5 Armor. NL Draw a card.

Python implementation:
class ShieldBlock(SpellCard):§    def __init__(self):§        super().__init__("Shield Block", 3, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        player.hero.increase_armor(5)§        player.draw()§
Card: Shiv NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $1 damage. Draw a card.

Python implementation:
class Shiv(SpellCard):§    def __init__(self):§        super().__init__("Shiv", 2, CHARACTER_CLASS.ROGUE, 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(1), self)§        player.draw()§
Card: Silver Hand Recruit NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Free RARITY_END NIL

Python implementation:
class SilverHandRecruit(MinionCard):§    def __init__(self):§        super().__init__("Silver Hand Recruit", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.FREE, False)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Soulfire 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 $4 damage. Discard a random card.

Python implementation:
class Soulfire(SpellCard):§    def __init__(self):§        super().__init__("Soulfire", 1, CHARACTER_CLASS.WARLOCK, 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(4), self)§        player.discard()§
Card: Sprint NAME_END -1 ATK_END -1 DEF_END 7 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Draw 4 cards.

Python implementation:
class Sprint(SpellCard):§    def __init__(self):§        super().__init__("Sprint", 7, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        for i in range(0, 4):§            player.draw()§
Card: Starfire NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $5 damage. NL Draw a card.

Python implementation:
class Starfire(SpellCard):§    def __init__(self):§        super().__init__("Starfire", 6, CHARACTER_CLASS.DRUID, 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(5), self)§        player.draw()§
Card: Starving Buzzard NAME_END 3 ATK_END 2 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Common RARITY_END Whenever you summon a Beast, draw a card.

Python implementation:
class StarvingBuzzard(MinionCard):§    def __init__(self):§        super().__init__("Starving Buzzard", 5, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(3, 2, effects=[Effect(MinionPlaced(IsType(MINION_TYPE.BEAST)), ActionTag(Draw(), PlayerSelector()))])§
Card: Stoneclaw 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>Taunt</b>

Python implementation:
class StoneclawTotem(MinionCard):§    def __init__(self):§        super().__init__("Stoneclaw Totem", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.FREE, False, MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(0, 2, taunt=True)§
Card: Stonetusk 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 Free RARITY_END <b>Charge</b>

Python implementation:
class StonetuskBoar(MinionCard):§    def __init__(self):§        super().__init__("Stonetusk Boar", 1, CHARACTER_CLASS.ALL, CARD_RARITY.FREE, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1, charge=True)§
Card: Stormpike Commando NAME_END 4 ATK_END 2 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Deal 2 damage.

Python implementation:
class StormpikeCommando(MinionCard):§    def __init__(self):§        super().__init__("Stormpike Commando", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Damage(2), CharacterSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(4, 2)§
Card: Stormwind Champion NAME_END 6 ATK_END 6 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Your other minions have +1/+1.

Python implementation:
class StormwindChampion(MinionCard):§    def __init__(self):§        super().__init__("Stormwind Champion", 7, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(6, 6, auras=[Aura(ChangeAttack(1), MinionSelector()), Aura(ChangeHealth(1), MinionSelector())])§
Card: Swipe NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $4 damage to an enemy and $1 damage to all other enemies.

Python implementation:
class Swipe(SpellCard):§    def __init__(self):§        super().__init__("Swipe", 4, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_enemy_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(4, self)§§        for minion in copy.copy(game.other_player.minions):§            if minion is not self.target:§                minion.damage(player.effective_spell_damage(1), self)§§        if self.target is not game.other_player.hero:§            game.other_player.hero.damage(player.effective_spell_damage(1), self)§
Card: Timber Wolf NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Free RARITY_END Your other Beasts have +1 Attack.

Python implementation:
class TimberWolf(MinionCard):§    def __init__(self):§        super().__init__("Timber Wolf", 1, CHARACTER_CLASS.HUNTER, CARD_RARITY.FREE, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1, auras=[Aura(ChangeAttack(1), MinionSelector(IsType(MINION_TYPE.BEAST)))])§
Card: Totemic Might NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Give your Totems +2 Health.

Python implementation:
class TotemicMight(SpellCard):§    def __init__(self):§        super().__init__("Totemic Might", 0, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        for minion in player.minions:§            if minion.card.minion_type == MINION_TYPE.TOTEM:§                minion.increase_health(2)§
Card: Tracking 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 Look at the top three cards of your deck. Draw one and discard the others.

Python implementation:
class Tracking(SpellCard):§    def __init__(self):§        super().__init__("Tracking", 1, CHARACTER_CLASS.HUNTER, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§        cards = []§        for card_index in range(0, 3):§            if player.can_draw():§                cards.append(player.deck.draw(game))§        if len(cards) > 0:§            chosen_card = player.agent.choose_option(cards, player)§            player.hand.append(chosen_card)§            player.hand[-1].player = player§            player.trigger("card_drawn", chosen_card)§
Card: Truesilver Champion NAME_END 4 ATK_END -1 DEF_END 4 COST_END 2 DUR_END Weapon TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever your hero attacks, restore 2 Health to it.

Python implementation:
class TruesilverChampion(WeaponCard):§    def __init__(self):§        super().__init__("Truesilver Champion", 4, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON)§§    def create_weapon(self, player):§        return Weapon(4, 2, effects=[Effect(CharacterAttack(IsHero()), ActionTag(Heal(2), HeroSelector()))])§
Card: Tundra Rhino NAME_END 2 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Common RARITY_END Your Beasts have <b>Charge</b>.

Python implementation:
class TundraRhino(MinionCard):§    def __init__(self):§        super().__init__("Tundra Rhino", 5, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(2, 5, charge=True, auras=[Aura(Charge(), MinionSelector(IsType(MINION_TYPE.BEAST)))])§
Card: Vanish NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Return all minions to their owner's hand.

Python implementation:
class Vanish(SpellCard):§    def __init__(self):§        super().__init__("Vanish", 6, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        targets = copy.copy(game.other_player.minions)§        targets.extend(player.minions)§§        for minion in sorted(targets, key=lambda m: m.born):§            minion.bounce()§
Card: Voidwalker NAME_END 1 ATK_END 3 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Free RARITY_END <b>Taunt</b>

Python implementation:
class Voidwalker(MinionCard):§    def __init__(self):§        super().__init__("Voidwalker", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.FREE, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(1, 3, taunt=True)§
Card: Warsong Commander NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Free RARITY_END Whenever you summon a minion with 3 or less Attack, give it <b>Charge</b>.

Python implementation:
class WarsongCommander(MinionCard):§    def __init__(self):§        super().__init__("Warsong Commander", 3, CHARACTER_CLASS.WARRIOR, CARD_RARITY.FREE)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(MinionPlaced(AttackLessThanOrEqualTo(3)), ActionTag(Give(Charge()), TargetSelector()))])§
Card: Water Elemental NAME_END 3 ATK_END 6 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Freeze</b> any character damaged by this minion.

Python implementation:
class WaterElemental(MinionCard):§    def __init__(self):§        super().__init__("Water Elemental", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 6, effects=[Effect(DidDamage(), ActionTag(Give(Frozen()), TargetSelector()))])§
Card: Whirlwind NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $1 damage to ALL minions.

Python implementation:
class Whirlwind(SpellCard):§    def __init__(self):§        super().__init__("Whirlwind", 1, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    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.damage(player.effective_spell_damage(1), self)§
Card: Wicked Knife NAME_END 1 ATK_END -1 DEF_END 1 COST_END 2 DUR_END Weapon TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Free RARITY_END NIL

Python implementation:
class WickedKnife(WeaponCard):§    def __init__(self):§        super().__init__("Wicked Knife", 1, CHARACTER_CLASS.ROGUE, CARD_RARITY.FREE, False)§§    def create_weapon(self, player):§        return Weapon(1, 2)§
Card: Wild Growth NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Free RARITY_END Gain an empty Mana Crystal.

Python implementation:
class WildGrowth(SpellCard):§    def __init__(self):§        super().__init__("Wild Growth", 2, CHARACTER_CLASS.DRUID, CARD_RARITY.FREE)§§    def use(self, player, game):§        super().use(player, game)§        if player.max_mana < 10:§            player.max_mana += 1§        else:§            player.hand.append(ExcessMana())§            player.hand[-1].player = player§
Card: Windfury NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Free RARITY_END Give a minion <b>Windfury</b>.

Python implementation:
class Windfury(SpellCard):§    def __init__(self):§        super().__init__("Windfury", 2, 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.add_buff(Buff(_Windfury()))§
Card: Windspeaker NAME_END 3 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Give a friendly minion <b>Windfury</b>.

Python implementation:
class Windspeaker(MinionCard):§    def __init__(self):§        super().__init__("Windspeaker", 4, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, battlecry=Battlecry(Give(Windfury()), MinionSelector(picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Wolfrider NAME_END 3 ATK_END 1 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Free RARITY_END <b>Charge</b>

Python implementation:
class Wolfrider(MinionCard):§    def __init__(self):§        super().__init__("Wolfrider", 3, CHARACTER_CLASS.ALL, CARD_RARITY.FREE)§§    def create_minion(self, player):§        return Minion(3, 1, charge=True)§
Card: Alexstrasza's Champion NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> If you're holding a Dragon, gain +1 Attack and <b>Charge</b>.

Python implementation:
class AlexstraszasChampion(MinionCard):§    def __init__(self):§        super().__init__("Alexstrasza's Champion", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE, battlecry=(Battlecry(Give([Buff(ChangeAttack(1)), Buff(Charge())]), SelfSelector(), GreaterThan(Count(CardSelector(condition=IsType(MINION_TYPE.DRAGON))), value=0))))§§    def create_minion(self, player):§        return Minion(2, 3)§
Card: Ancestral Knowledge NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Draw 2 cards. <b>Overload: (2)</b>

Python implementation:
class AncestralKnowledge(SpellCard):§    def __init__(self):§        super().__init__("Ancestral Knowledge", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, overload=2)§§    def use(self, player, game):§        super().use(player, game)§        for c in range(0, 2):§            player.draw()§
Card: Anub'arak NAME_END 8 ATK_END 4 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Deathrattle:</b> Return this to your hand and summon a 4/4 Nerubian.

Python implementation:
class Anubarak(MinionCard):§    def __init__(self):§        super().__init__("Anub'arak", 9, CHARACTER_CLASS.ROGUE, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(8, 4, deathrattle=[Deathrattle(Bounce(), SelfSelector()), Deathrattle(Summon(Nerubian()), PlayerSelector())])§
Card: Arcane Blast NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal $2 damage to a minion. This spell gets double bonus from <b>Spell Damage</b>.

Python implementation:
class ArcaneBlast(SpellCard):§    def __init__(self):§        super().__init__("Arcane Blast", 1, CHARACTER_CLASS.MAGE, CARD_RARITY.EPIC, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(player.effective_spell_damage(2 + player.spell_damage), self)§
Card: Argent Horserider NAME_END 2 ATK_END 1 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Charge</b> NL <b>Divine Shield</b>

Python implementation:
class ArgentHorserider(MinionCard):§    def __init__(self):§        super().__init__("Argent Horserider", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 1, charge=True, divine_shield=True)§
Card: Argent Lance NAME_END 2 ATK_END -1 DEF_END 2 COST_END 2 DUR_END Weapon TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Reveal a minion in each deck. If yours costs more, +1 Durability.

Python implementation:
class ArgentLance(WeaponCard):§    def __init__(self):§        super().__init__("Argent Lance", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE, battlecry=Battlecry(Joust(IncreaseDurability()), SelfSelector()))§§    def create_weapon(self, player):§        return Weapon(2, 2)§
Card: Argent Watchman NAME_END 2 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Can't attack. NL <b>Inspire:</b> Can attack as normal this turn.

Python implementation:
class ArgentWatchman(MinionCard):§    def __init__(self):§        super().__init__("Argent Watchman", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(2, 4, buffs=[Buff(CantAttack())], effects=[Effect(UsedPower(), ActionTag(Give(BuffUntil(CanAttack(), TurnEnded())), SelfSelector()))])§
Card: Armored Warhorse NAME_END 5 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Rare RARITY_END <b>Battlecry:</b> Reveal a minion in each deck. If yours costs more, gain <b>Charge</b>.

Python implementation:
class ArmoredWarhorse(MinionCard):§    def __init__(self):§        super().__init__("Armored Warhorse", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST, battlecry=Battlecry(Joust(Give(Buff(Charge()))), SelfSelector()))§§    def create_minion(self, player):§        return Minion(5, 3)§
Card: Healing Totem NAME_END 0 ATK_END 2 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END NIL RARITY_END At the end of your turn, restore 1 Health to all friendly minions.

Python implementation:
class HealingTotem(MinionCard):§    def __init__(self):§        super().__init__("Healing Totem", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.FREE, False, MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(0, 2, effects=[Effect(TurnEnded(), ActionTag(Heal(1), MinionSelector(condition=None)))])§
Card: Nerubian NAME_END 4 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class Nerubian(MinionCard):§    def __init__(self):§        super().__init__("Nerubian", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, False)§§    def create_minion(self, p):§        return Minion(4, 4)§
Card: Searing Totem NAME_END 1 ATK_END 1 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END NIL 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: Stoneclaw Totem NAME_END 0 ATK_END 2 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END NIL RARITY_END <b>Taunt</b>

Python implementation:
class StoneclawTotem(MinionCard):§    def __init__(self):§        super().__init__("Stoneclaw Totem", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.FREE, False, MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(0, 2, taunt=True)§
Card: Tournament Medic NAME_END 1 ATK_END 8 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Inspire:</b> Restore 2 Health to your hero.

Python implementation:
class TournamentMedic(MinionCard):§    def __init__(self):§        super().__init__("Tournament Medic", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 8, effects=[Effect(UsedPower(), ActionTag(Heal(2), HeroSelector()))])§
Card: Wrath of Air Totem NAME_END 0 ATK_END 2 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END NIL 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: Ancestor's Call NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Epic RARITY_END Put a random minion from each player's hand into the battlefield.

Python implementation:
class AncestorsCall(SpellCard):§    def __init__(self):§        super().__init__("Ancestor's Call", 4, CHARACTER_CLASS.SHAMAN, CARD_RARITY.EPIC)§§    def can_use(self, player, game):§        return super().can_use(player, game) and (len(player.minions) < 7 or len(player.opponent.minions) < 7)§§    def use(self, player, game):§        super().use(player, game)§        for player in game.players:§            minions = [card for card in player.hand if card.is_minion()]§            if len(minions) and len(player.minions) < 7:§                minion_card = game.random_choice(minions)§                minion_card.unattach()§                player.hand.remove(minion_card)§                minion_card.summon(player, game, len(player.minions))§
Card: Anima Golem NAME_END 9 ATK_END 9 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Mech RACE_END Epic RARITY_END At the end of each turn, destroy this minion if it's your only one.

Python implementation:
class AnimaGolem(MinionCard):§    def __init__(self):§        super().__init__("Anima Golem", 6, CHARACTER_CLASS.WARLOCK, CARD_RARITY.EPIC, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(9, 9, effects=[Effect(TurnEnded(MinionCountIs(1), BothPlayer()), ActionTag(Kill(), SelfSelector()))])§
Card: Antique Healbot NAME_END 3 ATK_END 3 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Battlecry:</b> Restore 8 Health to your hero.

Python implementation:
class AntiqueHealbot(MinionCard):§    def __init__(self):§        super().__init__("Antique Healbot", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH, battlecry=Battlecry(Heal(8), HeroSelector()))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Arcane Nullifier X-21 NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Taunt</b> NL Can't be targeted by spells or Hero Powers.

Python implementation:
class ArcaneNullifierX21(MinionCard):§    def __init__(self):§        super().__init__("Arcane Nullifier X-21", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 5, taunt=True, spell_targetable=False)§
Card: Armor Plating NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END Give a minion +1 Health.

Python implementation:
class ArmorPlating(SpellCard):§    def __init__(self):§        super().__init__("Armor Plating", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.increase_health(1)§