dvitel/hearthstone huggingface dataset:
Card: Blizzard NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $2 damage to all enemy minions and <b>Freeze</b> them.

Python implementation:
class Blizzard(SpellCard):§    def __init__(self):§        super().__init__("Blizzard", 6, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE)§§    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)§        for minion in game.other_player.minions:§            minion.add_buff(Buff(Frozen()))§
Card: Blood Fury NAME_END 3 ATK_END -1 DEF_END 3 COST_END 8 DUR_END Weapon TYPE_END Warlock PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class BloodFury(WeaponCard):§    def __init__(self):§        super().__init__("Blood Fury", 3, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, False)§§    def create_weapon(self, player):§        return Weapon(3, 8)§
Card: Blood Imp NAME_END 0 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Common RARITY_END <b>Stealth</b>. At the end of your turn, give another random friendly minion +1 Health.

Python implementation:
class BloodImp(MinionCard):§    def __init__(self):§        super().__init__("Blood Imp", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(0, 1, stealth=True, effects=[Effect(TurnEnded(), ActionTag(Give(ChangeHealth(1)), MinionSelector(picker=RandomPicker())))])§
Card: Blood Knight NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> All minions lose <b>Divine Shield</b>. Gain +3/+3 for each Shield lost.

Python implementation:
class BloodKnight(MinionCard):§    def __init__(self):§        super().__init__("Blood Knight", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=(Battlecry([Give([Buff(ChangeAttack(Count(MinionSelector(HasDivineShield(), BothPlayer())), 3)), Buff(ChangeHealth(Count(MinionSelector(HasDivineShield(), BothPlayer())), 3))])], SelfSelector()), Battlecry(RemoveDivineShields(), (MinionSelector(HasDivineShield(), BothPlayer())))))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Bloodmage Thalnos NAME_END 1 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Spell Damage +1</b>. <b>Deathrattle:</b> Draw a card.

Python implementation:
class BloodmageThalnos(MinionCard):§    def __init__(self):§        super().__init__("Bloodmage Thalnos", 2, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(1, 1, spell_damage=1, deathrattle=Deathrattle(Draw(), PlayerSelector()))§
Card: Bloodsail Corsair NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Rare RARITY_END <b>Battlecry:</b> Remove 1 Durability from your opponent's weapon.

Python implementation:
class BloodsailCorsair(MinionCard):§    def __init__(self):§        super().__init__("Bloodsail Corsair", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.PIRATE, battlecry=Battlecry(DecreaseDurability(), WeaponSelector(EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(1, 2)§
Card: Bloodsail Raider NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Common RARITY_END <b>Battlecry:</b> Gain Attack equal to the Attack of your weapon.

Python implementation:
class BloodsailRaider(MinionCard):§    def __init__(self):§        super().__init__("Bloodsail Raider", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.PIRATE, battlecry=Battlecry(Give(Buff(ChangeAttack(Attribute("base_attack", WeaponSelector())))), SelfSelector()))§§    def create_minion(self, player):§        return Minion(2, 3)§
Card: Cairne Bloodhoof NAME_END 4 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Deathrattle:</b> Summon a 4/5 Baine Bloodhoof.

Python implementation:
class CairneBloodhoof(MinionCard):§    def __init__(self):§        super().__init__("Cairne Bloodhoof", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(4, 5, deathrattle=Deathrattle(Summon(BaineBloodhoof()), PlayerSelector()))§
Card: Captain Greenskin NAME_END 5 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Legendary RARITY_END <b>Battlecry:</b> Give your weapon +1/+1.

Python implementation:
class CaptainGreenskin(MinionCard):§    def __init__(self):§        super().__init__("Captain Greenskin", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.PIRATE, battlecry=Battlecry([IncreaseWeaponAttack(1), IncreaseDurability()], WeaponSelector()))§§    def create_minion(self, player):§        return Minion(5, 4)§
Card: Cenarius NAME_END 5 ATK_END 8 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Choose One</b> - Give your other minions +2/+2; or Summon two 2/2 Treants with <b>Taunt</b>.

Python implementation:
class Cenarius(MinionCard):§    def __init__(self):§        super().__init__("Cenarius", 9, CHARACTER_CLASS.DRUID, CARD_RARITY.LEGENDARY, choices=[§            Choice(IncreaseStats(), Give([Buff(ChangeAttack(2)), Buff(ChangeHealth(2)), Buff(Taunt())]), MinionSelector()),§            Choice(SummonTreants(), Summon(TauntTreant(), 2), PlayerSelector())§        ])§§    def create_minion(self, player):§        return Minion(5, 8)§
Card: Circle of Healing 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 Restore #4 Health to ALL minions.

Python implementation:
class CircleOfHealing(SpellCard):§    def __init__(self):§        super().__init__("Circle of Healing", 0, CHARACTER_CLASS.PRIEST, 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 targets:§            minion.heal(player.effective_heal_power(4), self)§
Card: Cold Blood 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 a minion +2 Attack. <b>Combo:</b> +4 Attack instead.

Python implementation:
class ColdBlood(SpellCard):§    def __init__(self):§        super().__init__("Cold Blood", 1, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        if player.cards_played > 0:§            self.target.change_attack(4)§        else:§            self.target.change_attack(2)§
Card: Coldlight Oracle NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Rare RARITY_END <b>Battlecry:</b> Each player draws 2 cards.

Python implementation:
class ColdlightOracle(MinionCard):§    def __init__(self):§        super().__init__("Coldlight Oracle", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MURLOC, battlecry=Battlecry(Draw(2), PlayerSelector(players=BothPlayer())))§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Coldlight Seer NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Rare RARITY_END <b>Battlecry:</b> Give ALL other Murlocs +2 Health.

Python implementation:
class ColdlightSeer(MinionCard):§    def __init__(self):§        super().__init__("Coldlight Seer", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MURLOC, battlecry=Battlecry(Give(ChangeHealth(2)), MinionSelector(IsType(MINION_TYPE.MURLOC), BothPlayer())))§§    def create_minion(self, player):§        return Minion(2, 3)§
Card: Commanding Shout NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END Your minions can't be reduced below 1 Health this turn. Draw a card.

Python implementation:
class CommandingShout(SpellCard):§    def __init__(self):§        super().__init__("Commanding Shout", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        player.add_aura(AuraUntil(MinimumHealth(1), MinionSelector(), TurnEnded()))§§        player.draw()§
Card: Counterspell NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Secret:</b> When your opponent casts a spell, <b>Counter</b> it.

Python implementation:
class Counterspell(SecretCard):§    def __init__(self):§        super().__init__("Counterspell", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§§    def _reveal(self, card, index):§        if card.is_spell():§            card.cancel = True§            super().reveal()§§    def activate(self, player):§        player.game.current_player.bind("card_played", self._reveal)§§    def deactivate(self, player):§        player.game.current_player.unbind("card_played", self._reveal)§
Card: Crazed Alchemist NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Swap the Attack and Health of a minion.

Python implementation:
class CrazedAlchemist(MinionCard):§    def __init__(self):§        super().__init__("Crazed Alchemist", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(SwapStats('health', 'attack', False), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Cruel Taskmaster NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Deal 1 damage to a minion and give it +2 Attack.

Python implementation:
class CruelTaskmaster(MinionCard):§    def __init__(self):§        super().__init__("Cruel Taskmaster", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, battlecry=Battlecry([Damage(1), Give(ChangeAttack(2))], MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Cult Master NAME_END 4 ATK_END 2 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever one of your other minions dies, draw a card.

Python implementation:
class CultMaster(MinionCard):§    def __init__(self):§        super().__init__("Cult Master", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 2, effects=[Effect(MinionDied(), ActionTag(Draw(), PlayerSelector()))])§
Card: Damaged Golem NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END NIL

Python implementation:
class DamagedGolem(MinionCard):§    def __init__(self):§        super().__init__("Damaged Golem", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 1)§
Card: Dark Iron Dwarf NAME_END 4 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> Give a minion +2 Attack this turn.

Python implementation:
class DarkIronDwarf(MinionCard):§    def __init__(self):§        super().__init__("Dark Iron Dwarf", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Give(BuffUntil(ChangeAttack(2), TurnEnded(player=CurrentPlayer()))), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Deadly Shot 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 Destroy a random enemy minion.

Python implementation:
class DeadlyShot(SpellCard):§    def __init__(self):§        super().__init__("Deadly Shot", 3, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        targets = hearthbreaker.targeting.find_enemy_minion_battlecry_target(player.game, lambda x: True)§        target = game.random_choice(targets)§        target.die(None)§        game.check_delayed()§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) >= 1§
Card: Deathwing NAME_END 12 ATK_END 12 DEF_END 10 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Legendary RARITY_END <b>Battlecry:</b> Destroy all other minions and discard your hand.

Python implementation:
class Deathwing(MinionCard):§    def __init__(self):§        super().__init__("Deathwing", 10, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DRAGON, battlecry=(Battlecry(Kill(), MinionSelector(players=BothPlayer())), Battlecry(Discard(amount=Count(CardSelector())), PlayerSelector())))§§    def create_minion(self, player):§        return Minion(12, 12)§
Card: Defias Bandit NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Python implementation:
class DefiasBandit(MinionCard):§    def __init__(self):§        super().__init__("Defias Bandit", 1, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, False)§§    def create_minion(self, player):§        return Minion(2, 1)§
Card: Defias Ringleader NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Combo:</b> Summon a 2/1 Defias Bandit.

Python implementation:
class DefiasRingleader(MinionCard):§    def __init__(self):§        super().__init__("Defias Ringleader", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, combo=Battlecry(Summon(DefiasBandit()), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Demolisher NAME_END 1 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Rare RARITY_END At the start of your turn, deal 2 damage to a random enemy.

Python implementation:
class Demolisher(MinionCard):§    def __init__(self):§        super().__init__("Demolisher", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 4, effects=[Effect(TurnStarted(), ActionTag(Damage(2), CharacterSelector(players=EnemyPlayer(), picker=RandomPicker())))])§
Card: Demonfire NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $2 damage to a minion. If it’s a friendly Demon, give it +2/+2 instead.

Python implementation:
class Demonfire(SpellCard):§    def __init__(self):§        super().__init__("Demonfire", 2, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        targets = copy.copy(player.game.current_player.minions)§        if self.target.card.minion_type is MINION_TYPE.DEMON and self.target in targets:§            self.target.change_attack(2)§            self.target.increase_health(2)§        else:§            self.target.damage(player.effective_spell_damage(2), self)§
Card: Demonfire NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Enchantment TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Common RARITY_END This Demon has +2/+2.

Python implementation:
class Demonfire(SpellCard):§    def __init__(self):§        super().__init__("Demonfire", 2, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        targets = copy.copy(player.game.current_player.minions)§        if self.target.card.minion_type is MINION_TYPE.DEMON and self.target in targets:§            self.target.change_attack(2)§            self.target.increase_health(2)§        else:§            self.target.damage(player.effective_spell_damage(2), self)§
Card: Devilsaur 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 NIL

Python implementation:
class Devilsaur(MinionCard):§    def __init__(self):§        super().__init__("Devilsaur", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(5, 5)§
Card: Dire Wolf Alpha NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END Adjacent minions have +1 Attack.

Python implementation:
class DireWolfAlpha(MinionCard):§    def __init__(self):§        super().__init__("Dire Wolf Alpha", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(2, 2, auras=[Aura(ChangeAttack(1), MinionSelector(Adjacent()))])§
Card: Divine Favor NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END Draw cards until you have as many in hand as your opponent.

Python implementation:
class DivineFavor(SpellCard):§    def __init__(self):§        super().__init__("Divine Favor", 3, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        difference = len(game.other_player.hand) - len(player.hand)§        for i in range(0, difference):§            player.draw()§
Card: Doomsayer NAME_END 0 ATK_END 7 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END At the start of your turn, destroy ALL minions.

Python implementation:
class Doomsayer(MinionCard):§    def __init__(self):§        super().__init__("Doomsayer", 2, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(0, 7, effects=[Effect(TurnStarted(), ActionTag(Kill(), MinionSelector(condition=None, players=BothPlayer())))])§
Card: Dread Corsair NAME_END 3 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Common RARITY_END <b>Taunt.</b> Costs (1) less per Attack of your weapon.

Python implementation:
class DreadCorsair(MinionCard):§    def __init__(self):§        super().__init__("Dread Corsair", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.PIRATE, buffs=[Buff(ManaChange(Attribute("attack", WeaponSelector()), -1))])§§    def create_minion(self, player):§        return Minion(3, 3, taunt=True)§
Card: Dream NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Dream PLAYER_CLS_END NIL RACE_END NIL RARITY_END Return a minion to its owner's hand.

Python implementation:
class Dream(SpellCard):§    def __init__(self):§        super().__init__("Dream", 0, CHARACTER_CLASS.DREAM, CARD_RARITY.COMMON, False, hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.bounce()§
Card: Druid of the Claw NAME_END 4 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Taunt</b>

Python implementation:
class DruidOfTheClaw(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Claw", 5, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(CatForm(), Transform(CatDruid()), SelfSelector()),§            Choice(BearForm(), Transform(BearDruid()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Druid of the Claw NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Choose One -</b> <b>Charge</b>; or +2 Health and <b>Taunt</b>.

Python implementation:
class DruidOfTheClaw(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Claw", 5, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(CatForm(), Transform(CatDruid()), SelfSelector()),§            Choice(BearForm(), Transform(BearDruid()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Druid of the Claw NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Charge</b>

Python implementation:
class DruidOfTheClaw(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Claw", 5, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(CatForm(), Transform(CatDruid()), SelfSelector()),§            Choice(BearForm(), Transform(BearDruid()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(4, 4)§
Card: Dust Devil NAME_END 3 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Windfury</b>. <b>Overload:</b> (2)

Python implementation:
class DustDevil(MinionCard):§    def __init__(self):§        super().__init__("Dust Devil", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, overload=2)§§    def create_minion(self, player):§        return Minion(3, 1, windfury=True)§
Card: Eaglehorn Bow NAME_END 3 ATK_END -1 DEF_END 3 COST_END 2 DUR_END Weapon TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever a friendly <b>Secret</b> is revealed, gain +1 Durability.

Python implementation:
class EaglehornBow(WeaponCard):§    def __init__(self):§        super().__init__("Eaglehorn Bow", 3, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE)§§    def create_weapon(self, player):§        return Weapon(3, 2, effects=[Effect(SecretRevealed(), ActionTag(IncreaseDurability(), WeaponSelector()))])§
Card: Earthen Ring Farseer 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> Restore 3 Health.

Python implementation:
class EarthenRingFarseer(MinionCard):§    def __init__(self):§        super().__init__("Earthen Ring Farseer", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Heal(3), CharacterSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 3)§
Card: Edwin VanCleef NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Combo:</b> Gain +2/+2 for each card played earlier this turn.

Python implementation:
class EdwinVanCleef(MinionCard):§    def __init__(self):§        super().__init__("Edwin VanCleef", 3, CHARACTER_CLASS.ROGUE, CARD_RARITY.LEGENDARY, battlecry=Battlecry(Give([Buff(ChangeAttack(Attribute("cards_played", PlayerSelector()), 2)), Buff(ChangeHealth(Attribute("cards_played", PlayerSelector()), 2))]), SelfSelector()))§§    def create_minion(self, player):§        return Minion(2, 2)§
Card: Emerald Drake NAME_END 7 ATK_END 6 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Dream PLAYER_CLS_END Dragon RACE_END NIL RARITY_END NIL

Python implementation:
class EmeraldDrake(MinionCard):§    def __init__(self):§        super().__init__("Emerald Drake", 4, CHARACTER_CLASS.DREAM, CARD_RARITY.COMMON, False, MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        return Minion(7, 6)§
Card: Emperor Cobra NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Rare RARITY_END Destroy any minion damaged by this minion.

Python implementation:
class EmperorCobra(MinionCard):§    def __init__(self):§        super().__init__("Emperor Cobra", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(DidDamage(), ActionTag(Kill(), TargetSelector(IsMinion())))])§