dvitel/hearthstone huggingface dataset:
Card: Power Overwhelming 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 Give a friendly minion +4/+4 until end of turn. Then, it dies. Horribly.

Python implementation:
class PowerOverwhelming(SpellCard):§    def __init__(self):§        super().__init__("Power Overwhelming", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_friendly_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.add_effect(Effect(TurnEnded(), ActionTag(Kill(), SelfSelector())))§        self.target.change_attack(4)§        self.target.increase_health(4)§
Card: Priestess of Elune NAME_END 5 ATK_END 4 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Restore 4 Health to your hero.

Python implementation:
class PriestessOfElune(MinionCard):§    def __init__(self):§        super().__init__("Priestess of Elune", 6, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Heal(4), HeroSelector()))§§    def create_minion(self, player):§        return Minion(5, 4)§
Card: Prophet Velen NAME_END 7 ATK_END 7 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Double the damage and healing of your spells and Hero Power.

Python implementation:
class ProphetVelen(MinionCard):§    def __init__(self):§        super().__init__("Prophet Velen", 7, CHARACTER_CLASS.PRIEST, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 7, auras=[Aura(MultiplySpellDamage(2), PlayerSelector()), Aura(MultiplyHealAmount(2), PlayerSelector())])§
Card: Pyroblast NAME_END -1 ATK_END -1 DEF_END 10 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal $10 damage.

Python implementation:
class Pyroblast(SpellCard):§    def __init__(self):§        super().__init__("Pyroblast", 10, CHARACTER_CLASS.MAGE, CARD_RARITY.EPIC, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(player.effective_spell_damage(10), self)§
Card: Questing Adventurer NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever you play a card, gain +1/+1.

Python implementation:
class QuestingAdventurer(MinionCard):§    def __init__(self):§        super().__init__("Questing Adventurer", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(2, 2, effects=[Effect(CardPlayed(), ActionTag(Give([Buff(ChangeAttack(1)), Buff(ChangeHealth(1))]), SelfSelector()))])§
Card: Raging Worgen 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>Enrage:</b> <b>Windfury</b> and +1 Attack

Python implementation:
class RagingWorgen(MinionCard):§    def __init__(self):§        super().__init__("Raging Worgen", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 3, enrage=[Aura(ChangeAttack(1), SelfSelector()), Aura(Windfury(), SelfSelector())])§
Card: Ragnaros the Firelord NAME_END 8 ATK_END 8 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Can't attack. At the end of your turn, deal 8 damage to a random enemy.

Python implementation:
class RagnarosTheFirelord(MinionCard):§    def __init__(self):§        super().__init__("Ragnaros the Firelord", 8, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(8, 8, effects=[Effect(TurnEnded(), ActionTag(Damage(8), CharacterSelector(players=EnemyPlayer(), picker=RandomPicker())))], buffs=[Buff(CantAttack())])§
Card: Rampage 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 Give a damaged minion +3/+3.

Python implementation:
class Rampage(SpellCard):§    def __init__(self):§        super().__init__("Rampage", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, 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.change_attack(3)§        self.target.increase_health(3)§
Card: Ravenholdt Assassin NAME_END 7 ATK_END 5 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Stealth</b>

Python implementation:
class RavenholdtAssassin(MinionCard):§    def __init__(self):§        super().__init__("Ravenholdt Assassin", 7, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(7, 5, stealth=True)§
Card: SI:7 Agent NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Combo:</b> Deal 2 damage.

Python implementation:
class SI7Agent(MinionCard):§    def __init__(self):§        super().__init__("SI:7 Agent", 3, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE, combo=Battlecry(Damage(2), CharacterSelector( players=BothPlayer(), picker=UserPicker()) ))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Savagery NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal damage equal to your hero's Attack to a minion.

Python implementation:
class Savagery(SpellCard):§    def __init__(self):§        super().__init__("Savagery", 1, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.damage(player.effective_spell_damage(player.hero.calculate_attack()), self)§
Card: Savannah Highmane NAME_END 6 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Rare RARITY_END <b>Deathrattle:</b> Summon two 2/2 Hyenas.

Python implementation:
class SavannahHighmane(MinionCard):§    def __init__(self):§        super().__init__("Savannah Highmane", 6, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(6, 5, deathrattle=Deathrattle(Summon(Hyena(), 2), PlayerSelector()))§
Card: Scarlet Crusader NAME_END 3 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>Divine Shield</b>

Python implementation:
class ScarletCrusader(MinionCard):§    def __init__(self):§        super().__init__("Scarlet Crusader", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 1, divine_shield=True)§
Card: Scavenging Hyena NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Common RARITY_END Whenever a friendly Beast dies, gain +2/+1.

Python implementation:
class ScavengingHyena(MinionCard):§    def __init__(self):§        super().__init__("Scavenging Hyena", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(2, 2, effects=[Effect(MinionDied(IsType(MINION_TYPE.BEAST)), ActionTag(Give(ChangeAttack(2)), SelfSelector())), Effect(MinionDied(IsType(MINION_TYPE.BEAST)), ActionTag(Give(ChangeHealth(1)), SelfSelector()))])§
Card: Sea Giant NAME_END 8 ATK_END 8 DEF_END 10 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END Costs (1) less for each other minion on the battlefield.

Python implementation:
class SeaGiant(MinionCard):§    def __init__(self):§        super().__init__("Sea Giant", 10, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, buffs=[Buff(ManaChange(Count(MinionSelector(None, BothPlayer())), -1))])§§    def create_minion(self, player):§        return Minion(8, 8)§
Card: Secretkeeper NAME_END 1 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 a <b>Secret</b> is played, gain +1/+1.

Python implementation:
class Secretkeeper(MinionCard):§    def __init__(self):§        super().__init__("Secretkeeper", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(1, 2, effects=[Effect(SpellCast(IsSecret(), BothPlayer()), ActionTag(Give([Buff(ChangeAttack(1)), Buff(ChangeHealth(1))]), SelfSelector()))])§
Card: Sense Demons NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Common RARITY_END Put 2 random Demons from your deck into your hand.

Python implementation:
class SenseDemons(SpellCard):§    def __init__(self):§        super().__init__("Sense Demons", 3, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        for i in range(0, 2):§            demon_card = game.random_draw(game.current_player.deck.cards, lambda c: not c.drawn and c.is_minion() and c.minion_type == MINION_TYPE.DEMON)§            if demon_card:§                demon_card.drawn = True§                player.deck.left -= 1§                if len(player.hand) < 10:§                    player.hand.append(demon_card)§                    demon_card.player = player§                    self.trigger("card_drawn", demon_card)§                else:§                    player.trigger("card_destroyed", demon_card)§            else:§                if len(player.hand) < 10:§                    player.hand.append(hearthbreaker.cards.minions.warlock.WorthlessImp())§                    player.hand[-1].player = player§                    self.trigger("card_drawn", hearthbreaker.cards.minions.warlock.WorthlessImp())§
Card: Shadowflame NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Rare RARITY_END Destroy a friendly minion and deal its Attack damage to all enemy minions.

Python implementation:
class Shadowflame(SpellCard):§    def __init__(self):§        super().__init__("Shadowflame", 4, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_friendly_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        shadowflame_damage = self.target.calculate_attack()§        self.target.die(self)§        for minion in game.other_player.minions:§            minion.damage(player.effective_spell_damage(shadowflame_damage), self)§
Card: Shadowform NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Epic RARITY_END Your Hero Power becomes 'Deal 2 damage'. If already in Shadowform: 3 damage.

Python implementation:
class Shadowform(SpellCard):§    def __init__(self):§        super().__init__("Shadowform", 3, CHARACTER_CLASS.PRIEST, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§§        if type(player.hero.power) is not hearthbreaker.powers.MindShatter and type( player.hero.power) is not hearthbreaker.powers.MindSpike:§            player.hero.power = hearthbreaker.powers.MindSpike()§            player.hero.power.hero = player.hero§        elif type(player.hero.power) is hearthbreaker.powers.MindSpike:§            player.hero.power = hearthbreaker.powers.MindShatter()§            player.hero.power.hero = player.hero§
Card: Shadowstep NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Return a friendly minion to your hand. It costs (2) less.

Python implementation:
class Shadowstep(SpellCard):§    def __init__(self):§        super().__init__("Shadowstep", 0, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_friendly_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.bounce()§        self.target.card.add_buff(Buff(ManaChange(-3)))§
Card: Shield Slam NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal 1 damage to a minion for each Armor you have.

Python implementation:
class ShieldSlam(SpellCard):§    def __init__(self):§        super().__init__("Shield Slam", 1, CHARACTER_CLASS.WARRIOR, 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(player.hero.armor), self)§
Card: Shieldbearer NAME_END 0 ATK_END 4 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 Shieldbearer(MinionCard):§    def __init__(self):§        super().__init__("Shieldbearer", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(0, 4, taunt=True)§
Card: Silence NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Silence</b> a minion.

Python implementation:
class Silence(SpellCard):§    def __init__(self):§        super().__init__("Silence", 0, 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.silence()§
Card: Silver Hand Knight 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> Summon a 2/2 Squire.

Python implementation:
class SilverHandKnight(MinionCard):§    def __init__(self):§        super().__init__("Silver Hand Knight", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Summon(Squire()), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Silvermoon Guardian NAME_END 3 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Divine Shield</b>

Python implementation:
class SilvermoonGuardian(MinionCard):§    def __init__(self):§        super().__init__("Silvermoon Guardian", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 3, divine_shield=True)§
Card: Snake NAME_END 1 ATK_END 1 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Common RARITY_END NIL

Python implementation:
class Snake(MinionCard):§    def __init__(self):§        super().__init__("Snake", 0, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Snake 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 Epic RARITY_END <b>Secret:</b> When one of your minions is attacked, summon three 1/1 Snakes.

Python implementation:
class SnakeTrap(SecretCard):§    def __init__(self):§        super().__init__("Snake Trap", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.EPIC)§§    def activate(self, player):§        player.game.current_player.bind("character_attack", self._reveal)§§    def deactivate(self, player):§        player.game.current_player.unbind("character_attack", self._reveal)§§    def _reveal(self, attacker, target):§        if isinstance(target, Minion):§            snake = hearthbreaker.cards.minions.hunter.Snake()§            player = target.player.game.other_player§            for i in range(0, 3):§                snake.summon(player, player.game, len(player.minions))§            super().reveal()§
Card: Snipe 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 opponent plays a minion, deal $4 damage to it.

Python implementation:
class Snipe(SecretCard):§    def __init__(self):§        super().__init__("Snipe", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON)§§    def activate(self, player):§        player.game.current_player.bind("minion_played", self._reveal)§§    def deactivate(self, player):§        player.game.current_player.unbind("minion_played", self._reveal)§§    def _reveal(self, minion):§        minion.damage(4, None)§        super().reveal()§
Card: Sorcerer's Apprentice NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END Your spells cost (1) less.

Python implementation:
class SorcerersApprentice(MinionCard):§    def __init__(self):§        super().__init__("Sorcerer's Apprentice", 2, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 2, auras=[Aura(ManaChange(-1), CardSelector(condition=IsSpell()))])§
Card: Soul of the Forest 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 Give your minions "<b>Deathrattle:</b> Summon a 2/2 Treant."

Python implementation:
class SoulOfTheForest(SpellCard):§    def __init__(self):§        super().__init__("Soul of the Forest", 4, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        from hearthbreaker.cards.minions.druid import Treant§        for minion in player.minions:§            minion.deathrattle.append(Deathrattle(Summon(Treant()), PlayerSelector()))§
Card: Southsea Captain NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Epic RARITY_END Your other Pirates have +1/+1.

Python implementation:
class SouthseaCaptain(MinionCard):§    def __init__(self):§        super().__init__("Southsea Captain", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, minion_type=MINION_TYPE.PIRATE)§§    def create_minion(self, player):§        return Minion(3, 3, auras=[Aura(ChangeAttack(1), MinionSelector(IsType(MINION_TYPE.PIRATE))), Aura(ChangeHealth(1), MinionSelector(IsType(MINION_TYPE.PIRATE)))])§
Card: Southsea Deckhand NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Common RARITY_END Has <b>Charge</b> while you have a weapon equipped.

Python implementation:
class SouthseaDeckhand(MinionCard):§    def __init__(self):§        super().__init__("Southsea Deckhand", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.PIRATE)§§    def create_minion(self, player):§        return Minion(2, 1, buffs=[Buff(Charge(), GreaterThan(Count(WeaponSelector()), value=0))])§
Card: Spellbender NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Secret:</b> When an enemy casts a spell on a minion, summon a 1/3 as the new target.

Python implementation:
class Spellbender(SecretCard):§    def __init__(self):§        super().__init__("Spellbender", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.EPIC)§        self.player = None§§    def _reveal(self, card, index):§        if card.is_spell() and len(self.player.minions) < 7 and card.target and card.target.is_minion():§            SpellbenderMinion().summon(self.player, self.player.game, len(self.player.minions))§            card.target = self.player.minions[-1]§            super().reveal()§§    def activate(self, player):§        player.game.current_player.bind("card_played", self._reveal)§        self.player = player§§    def deactivate(self, player):§        player.game.current_player.unbind("card_played", self._reveal)§        self.player = None§
Card: Spirit Wolf NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Taunt</b>

Python implementation:
class SpiritWolf(MinionCard):§    def __init__(self):§        super().__init__("Spirit Wolf", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, False)§§    def create_minion(self, p):§        return Minion(2, 3, taunt=True)§
Card: Spiteful Smith NAME_END 4 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Enrage:</b> Your weapon has +2 Attack.

Python implementation:
class SpitefulSmith(MinionCard):§    def __init__(self):§        super().__init__("Spiteful Smith", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 6, enrage=[Aura(ChangeAttack(2), WeaponSelector())])§
Card: Squire NAME_END 2 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END NIL

Python implementation:
class Squire(MinionCard):§    def __init__(self):§        super().__init__("Squire", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False)§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Squirrel 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 Squirrel(MinionCard):§    def __init__(self):§        super().__init__("Squirrel", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1)§
Card: Stampeding Kodo NAME_END 3 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Rare RARITY_END <b>Battlecry:</b> Destroy a random enemy minion with 2 or less Attack.

Python implementation:
class StampedingKodo(MinionCard):§    def __init__(self):§        super().__init__("Stampeding Kodo", 5, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST, battlecry=Battlecry(Kill(), MinionSelector(AttackLessThanOrEqualTo(2), EnemyPlayer(), RandomPicker())))§§    def create_minion(self, player):§        return Minion(3, 5)§
Card: Starfall NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Choose One -</b> Deal $5 damage to a minion; or $2 damage to all enemy minions.

Python implementation:
class Starfall(SpellCard):§    def __init__(self):§        super().__init__("Starfall", 5, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE)§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) > 0§§    def use(self, player, game):§        super().use(player, game)§        option = player.agent.choose_option([DamageAll(), DamageOne()], player)§        option.use(player, game)§
Card: Stormforged Axe NAME_END 2 ATK_END -1 DEF_END 2 COST_END 3 DUR_END Weapon TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Overload:</b> (1)

Python implementation:
class StormforgedAxe(WeaponCard):§    def __init__(self):§        super().__init__("Stormforged Axe", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, overload=1)§§    def create_weapon(self, player):§        return Weapon(2, 3)§
Card: Stranglethorn Tiger NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Stealth</b>

Python implementation:
class StranglethornTiger(MinionCard):§    def __init__(self):§        super().__init__("Stranglethorn Tiger", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(5, 5, stealth=True)§
Card: Sunwalker NAME_END 4 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Taunt</b> NL <b>Divine Shield</b>

Python implementation:
class Sunwalker(MinionCard):§    def __init__(self):§        super().__init__("Sunwalker", 6, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(4, 5, divine_shield=True, taunt=True)§