spells-mtg 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

spells/__init__.py

@@ -1,5 +1,5 @@
-from spells import columns
-from spells import enums
+from spells.columns import ColSpec
+from spells.enums import ColType, ColName
 from spells.draft_data import summon
 
-__all__ = ["summon", "enums", "columns"]
+__all__ = ["summon", "ColSpec", "ColType", "ColName"]

spells/columns.py

@@ -7,8 +7,7 @@ from spells.enums import View, ColName, ColType
 
 
 @dataclass(frozen=True)
-class ColumnSpec:
-    name: str
+class ColSpec:
     col_type: ColType
     expr: pl.Expr | Callable[..., pl.Expr] | None = None
     views: list[View] | None = None
@@ -16,7 +15,7 @@ class ColumnSpec:
 
 
 @dataclass(frozen=True)
-class ColumnDefinition:
+class ColDef:
     name: str
     col_type: ColType
     expr: pl.Expr | tuple[pl.Expr, ...]
@@ -41,69 +40,56 @@ default_columns = [
     ColName.GIH_WR,
 ]
 
-_column_specs = [
-    ColumnSpec(
-        name=ColName.NAME,
+specs: dict[str, ColSpec] = {
+    ColName.NAME: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.CARD],
     ),
-    ColumnSpec(
-        name=ColName.EXPANSION,
+    ColName.EXPANSION: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME, View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.EVENT_TYPE,
+    ColName.EVENT_TYPE: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME, View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.DRAFT_ID,
+    ColName.DRAFT_ID: ColSpec(
         views=[View.GAME, View.DRAFT],
         col_type=ColType.FILTER_ONLY,
     ),
-    ColumnSpec(
-        name=ColName.DRAFT_TIME,
+    ColName.DRAFT_TIME: ColSpec(
         col_type=ColType.FILTER_ONLY,
         views=[View.GAME, View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.DRAFT_DATE,
+    ColName.DRAFT_DATE: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.DRAFT_TIME).str.to_datetime("%Y-%m-%d %H:%M:%S").dt.date(),
     ),
-    ColumnSpec(
-        name=ColName.DRAFT_DAY_OF_WEEK,
+    ColName.DRAFT_DAY_OF_WEEK: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.DRAFT_TIME).str.to_datetime("%Y-%m-%d %H:%M:%S").dt.weekday(),
     ),
-    ColumnSpec(
-        name=ColName.DRAFT_HOUR,
+    ColName.DRAFT_HOUR: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.DRAFT_TIME).str.to_datetime("%Y-%m-%d %H:%M:%S").dt.hour(),
     ),
-    ColumnSpec(
-        name=ColName.DRAFT_WEEK,
+    ColName.DRAFT_WEEK: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.DRAFT_TIME).str.to_datetime("%Y-%m-%d %H:%M:%S").dt.week(),
     ),
-    ColumnSpec(
-        name=ColName.RANK,
+    ColName.RANK: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME, View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.USER_N_GAMES_BUCKET,
+    ColName.USER_N_GAMES_BUCKET: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.DRAFT, View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.USER_GAME_WIN_RATE_BUCKET,
+    ColName.USER_GAME_WIN_RATE_BUCKET: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.DRAFT, View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.PLAYER_COHORT,
+    ColName.PLAYER_COHORT: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.when(pl.col(ColName.USER_N_GAMES_BUCKET) < 100)
         .then(pl.lit("Other"))
@@ -117,304 +103,249 @@ _column_specs = [
             )
         ),
     ),
-    ColumnSpec(
-        name=ColName.EVENT_MATCH_WINS,
+    ColName.EVENT_MATCH_WINS: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.EVENT_MATCH_WINS_SUM,
+    ColName.EVENT_MATCH_WINS_SUM: ColSpec(
         col_type=ColType.PICK_SUM,
         views=[View.DRAFT],
         expr=pl.col(ColName.EVENT_MATCH_WINS),
     ),
-    ColumnSpec(
-        name=ColName.EVENT_MATCH_LOSSES,
+    ColName.EVENT_MATCH_LOSSES: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.EVENT_MATCH_LOSSES_SUM,
+    ColName.EVENT_MATCH_LOSSES_SUM: ColSpec(
         col_type=ColType.PICK_SUM,
         expr=pl.col(ColName.EVENT_MATCH_LOSSES),
     ),
-    ColumnSpec(
-        name=ColName.EVENT_MATCHES,
+    ColName.EVENT_MATCHES: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.EVENT_MATCH_WINS) + pl.col(ColName.EVENT_MATCH_LOSSES),
     ),
-    ColumnSpec(
-        name=ColName.EVENT_MATCHES_SUM,
+    ColName.EVENT_MATCHES_SUM: ColSpec(
         col_type=ColType.PICK_SUM,
         expr=pl.col(ColName.EVENT_MATCHES),
     ),
-    ColumnSpec(
-        name=ColName.IS_TROPHY,
+    ColName.IS_TROPHY: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.when(pl.col(ColName.EVENT_TYPE) == "Traditional")
         .then(pl.col(ColName.EVENT_MATCH_WINS) == 3)
         .otherwise(pl.col(ColName.EVENT_MATCH_WINS) == 7),
     ),
-    ColumnSpec(
-        name=ColName.IS_TROPHY_SUM,
+    ColName.IS_TROPHY_SUM: ColSpec(
         col_type=ColType.PICK_SUM,
         expr=pl.col(ColName.IS_TROPHY),
     ),
-    ColumnSpec(
-        name=ColName.PACK_NUMBER,
+    ColName.PACK_NUMBER: ColSpec(
         col_type=ColType.FILTER_ONLY,  # use pack_num
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.PACK_NUM,
+    ColName.PACK_NUM: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.PACK_NUMBER) + 1,
     ),
-    ColumnSpec(
-        name=ColName.PICK_NUMBER,
+    ColName.PICK_NUMBER: ColSpec(
         col_type=ColType.FILTER_ONLY,  # use pick_num
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.PICK_NUM,
+    ColName.PICK_NUM: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.PICK_NUMBER) + 1,
     ),
-    ColumnSpec(
-        name=ColName.TAKEN_AT,
+    ColName.TAKEN_AT: ColSpec(
         col_type=ColType.PICK_SUM,
         expr=pl.col(ColName.PICK_NUM),
     ),
-    ColumnSpec(
-        name=ColName.NUM_TAKEN,
+    ColName.NUM_TAKEN: ColSpec(
         col_type=ColType.PICK_SUM,
         expr=pl.when(pl.col(ColName.PICK).is_not_null())
         .then(1)
         .otherwise(0),
     ),
-    ColumnSpec(
-        name=ColName.PICK,
+    ColName.NUM_DRAFTS: ColSpec(
+        col_type=ColType.PICK_SUM,
+        expr=pl.when((pl.col(ColName.PACK_NUMBER) == 0) & (pl.col(ColName.PICK_NUMBER) == 0)).then(1).otherwise(0),
+    ),
+    ColName.PICK: ColSpec(
         col_type=ColType.FILTER_ONLY,
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.PICK_MAINDECK_RATE,
+    ColName.PICK_MAINDECK_RATE: ColSpec(
         col_type=ColType.PICK_SUM,
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.PICK_SIDEBOARD_IN_RATE,
+    ColName.PICK_SIDEBOARD_IN_RATE: ColSpec(
         col_type=ColType.PICK_SUM,
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.PACK_CARD,
+    ColName.PACK_CARD: ColSpec(
         col_type=ColType.NAME_SUM,
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.LAST_SEEN,
+    ColName.LAST_SEEN: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(f"pack_card_{name}")
         * pl.min_horizontal(ColName.PICK_NUM, 8),
     ),
-    ColumnSpec(
-        name=ColName.NUM_SEEN,
+    ColName.NUM_SEEN: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(f"pack_card_{name}") * (pl.col(ColName.PICK_NUM) <= 8),
     ),
-    ColumnSpec(
-        name=ColName.POOL,
+    ColName.POOL: ColSpec(
         col_type=ColType.NAME_SUM,
         views=[View.DRAFT],
     ),
-    ColumnSpec(
-        name=ColName.GAME_TIME,
+    ColName.GAME_TIME: ColSpec(
         col_type=ColType.FILTER_ONLY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.GAME_DATE,
+    ColName.GAME_DATE: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.GAME_TIME).str.to_datetime("%Y-%m-%d %H-%M-%S").dt.date(),
     ),
-    ColumnSpec(
-        name=ColName.GAME_DAY_OF_WEEK,
+    ColName.GAME_DAY_OF_WEEK: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.GAME_TIME).str.to_datetime("%Y-%m-%d %H-%M-%S").dt.weekday(),
     ),
-    ColumnSpec(
-        name=ColName.GAME_HOUR,
+    ColName.GAME_HOUR: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.GAME_TIME).str.to_datetime("%Y-%m-%d %H-%M-%S").dt.hour(),
     ),
-    ColumnSpec(
-        name=ColName.GAME_WEEK,
+    ColName.GAME_WEEK: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.GAME_TIME).str.to_datetime("%Y-%m-%d %H-%M-%S").dt.week(),
     ),
-    ColumnSpec(
-        name=ColName.BUILD_INDEX,
+    ColName.BUILD_INDEX: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.MATCH_NUMBER,
+    ColName.MATCH_NUMBER: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.GAME_NUMBER,
+    ColName.GAME_NUMBER: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.NUM_GAMES,
+    ColName.NUM_GAMES: ColSpec(
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.GAME_NUMBER).is_not_null(),
     ),
-    ColumnSpec(
-        name=ColName.NUM_MATCHES,
+    ColName.NUM_MATCHES: ColSpec(
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.GAME_NUMBER) == 1,
     ),
-    ColumnSpec(
-        name=ColName.NUM_EVENTS,
+    ColName.NUM_EVENTS: ColSpec(
         col_type=ColType.GAME_SUM,
         expr=(pl.col(ColName.GAME_NUMBER) == 1) & (pl.col(ColName.MATCH_NUMBER) == 1),
     ),
-    ColumnSpec(
-        name=ColName.OPP_RANK,
+    ColName.OPP_RANK: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.MAIN_COLORS,
+    ColName.MAIN_COLORS: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.NUM_COLORS,
+    ColName.NUM_COLORS: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.MAIN_COLORS).str.len_chars(),
     ),
-    ColumnSpec(
-        name=ColName.SPLASH_COLORS,
+    ColName.SPLASH_COLORS: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.HAS_SPLASH,
+    ColName.HAS_SPLASH: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.SPLASH_COLORS).str.len_chars() > 0,
     ),
-    ColumnSpec(
-        name=ColName.ON_PLAY,
+    ColName.ON_PLAY: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.NUM_ON_PLAY,
+    ColName.NUM_ON_PLAY: ColSpec(
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.ON_PLAY),
     ),
-    ColumnSpec(
-        name=ColName.NUM_MULLIGANS,
+    ColName.NUM_MULLIGANS: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.NUM_MULLIGANS_SUM,
+    ColName.NUM_MULLIGANS_SUM: ColSpec(
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.NUM_MULLIGANS),
     ),
-    ColumnSpec(
-        name=ColName.OPP_NUM_MULLIGANS,
+    ColName.OPP_NUM_MULLIGANS: ColSpec(
         col_type=ColType.GAME_SUM,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.OPP_NUM_MULLIGANS_SUM,
+    ColName.OPP_NUM_MULLIGANS_SUM: ColSpec(
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.OPP_NUM_MULLIGANS),
     ),
-    ColumnSpec(
-        name=ColName.OPP_COLORS,
+    ColName.OPP_COLORS: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.NUM_TURNS,
+    ColName.NUM_TURNS: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.NUM_TURNS_SUM,
+    ColName.NUM_TURNS_SUM: ColSpec(
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.NUM_TURNS),
     ),
-    ColumnSpec(
-        name=ColName.WON,
+    ColName.WON: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.NUM_WON,
+    ColName.NUM_WON: ColSpec(
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.WON),
     ),
-    ColumnSpec(
-        name=ColName.OPENING_HAND,
+    ColName.OPENING_HAND: ColSpec(
         col_type=ColType.NAME_SUM,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.WON_OPENING_HAND,
+    ColName.WON_OPENING_HAND: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(f"opening_hand_{name}") * pl.col(ColName.WON),
     ),
-    ColumnSpec(
-        name=ColName.DRAWN,
+    ColName.DRAWN: ColSpec(
         col_type=ColType.NAME_SUM,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.WON_DRAWN,
+    ColName.WON_DRAWN: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(f"drawn_{name}") * pl.col(ColName.WON),
     ),
-    ColumnSpec(
-        name=ColName.TUTORED,
+    ColName.TUTORED: ColSpec(
         col_type=ColType.NAME_SUM,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.WON_TUTORED,
+    ColName.WON_TUTORED: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(f"tutored_{name}") * pl.col(ColName.WON),
     ),
-    ColumnSpec(
-        name=ColName.DECK,
+    ColName.DECK: ColSpec(
         col_type=ColType.NAME_SUM,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.WON_DECK,
+    ColName.WON_DECK: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(f"deck_{name}") * pl.col(ColName.WON),
     ),
-    ColumnSpec(
-        name=ColName.SIDEBOARD,
+    ColName.SIDEBOARD: ColSpec(
         col_type=ColType.NAME_SUM,
         views=[View.GAME],
     ),
-    ColumnSpec(
-        name=ColName.WON_SIDEBOARD,
+    ColName.WON_SIDEBOARD: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(f"sideboard_{name}") * pl.col(ColName.WON),
     ),
-    ColumnSpec(
-        name=ColName.NUM_GNS,
+    ColName.NUM_GNS: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.max_horizontal(
             0,
@@ -424,258 +355,204 @@ _column_specs = [
             - pl.col(f"opening_hand_{name}"),
         ),
     ),
-    ColumnSpec(
-        name=ColName.WON_NUM_GNS,
+    ColName.WON_NUM_GNS: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(ColName.WON) * pl.col(f"num_gns_{name}"),
     ),
-    ColumnSpec(
-        name=ColName.SET_CODE,
+    ColName.SET_CODE: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.COLOR,
+    ColName.COLOR: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.RARITY,
+    ColName.RARITY: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.COLOR_IDENTITY,
+    ColName.COLOR_IDENTITY: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.CARD_TYPE,
+    ColName.CARD_TYPE: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.SUBTYPE,
+    ColName.SUBTYPE: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.MANA_VALUE,
+    ColName.MANA_VALUE: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.DECK_MANA_VALUE,
+    ColName.DECK_MANA_VALUE: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name, card_context: card_context[name][ColName.MANA_VALUE] * pl.col(f"deck_{name}"),
     ),
-    ColumnSpec(
-        name=ColName.DECK_LANDS,
+    ColName.DECK_LANDS: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name, card_context: pl.col(f"deck_{name}") * ( 1 if 'Land' in card_context[name][ColName.CARD_TYPE] else 0 )
     ),
-    ColumnSpec(
-        name=ColName.DECK_SPELLS,
+    ColName.DECK_SPELLS: ColSpec(
         col_type=ColType.NAME_SUM,
         expr=lambda name: pl.col(f"deck_{name}") - pl.col(f"deck_lands_{name}"),
     ),
-    ColumnSpec(
-        name=ColName.MANA_COST,
+    ColName.MANA_COST: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.POWER,
+    ColName.POWER: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.TOUGHNESS,
+    ColName.TOUGHNESS: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.IS_BONUS_SHEET,
+    ColName.IS_BONUS_SHEET: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.IS_DFC,
+    ColName.IS_DFC: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.ORACLE_TEXT,
+    ColName.ORACLE_TEXT: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.CARD_JSON,
+    ColName.CARD_JSON: ColSpec(
         col_type=ColType.CARD_ATTR,
     ),
-    ColumnSpec(
-        name=ColName.PICKED_MATCH_WR,
+    ColName.PICKED_MATCH_WR: ColSpec(
         col_type=ColType.AGG,
-        expr=pl.col(ColName.EVENT_MATCH_WINS_SUM) / pl.col(ColName.EVENT_MATCHES),
+        expr=pl.col(ColName.EVENT_MATCH_WINS_SUM) / pl.col(ColName.EVENT_MATCHES_SUM),
     ),
-    ColumnSpec(
-        name=ColName.TROPHY_RATE,
+    ColName.TROPHY_RATE: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.IS_TROPHY_SUM) / pl.col(ColName.NUM_TAKEN),
     ),
-    ColumnSpec(
-        name=ColName.GAME_WR,
+    ColName.GAME_WR: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.NUM_WON) / pl.col(ColName.NUM_GAMES),
     ),
-    ColumnSpec(
-        name=ColName.ALSA,
+    ColName.ALSA: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.LAST_SEEN) / pl.col(ColName.NUM_SEEN),
     ),
-    ColumnSpec(
-        name=ColName.ATA,
+    ColName.ATA: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.TAKEN_AT) / pl.col(ColName.NUM_TAKEN),
     ),
-    ColumnSpec(
-        name=ColName.NUM_GP,
+    ColName.NUM_GP: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK),
     ),
-    ColumnSpec(
-        name=ColName.PCT_GP,
+    ColName.PCT_GP: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK) / (pl.col(ColName.DECK) + pl.col(ColName.SIDEBOARD)),
     ),
-    ColumnSpec(
-        name=ColName.GP_WR,
+    ColName.GP_WR: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_DECK) / pl.col(ColName.DECK),
     ),
-    ColumnSpec(
-        name=ColName.NUM_OH,
+    ColName.NUM_OH: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.OPENING_HAND),
     ),
-    ColumnSpec(
-        name=ColName.OH_WR,
+    ColName.OH_WR: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_OPENING_HAND) / pl.col(ColName.OPENING_HAND),
     ),
-    ColumnSpec(
-        name=ColName.NUM_GIH,
+    ColName.NUM_GIH: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.OPENING_HAND) + pl.col(ColName.DRAWN),
     ),
-    ColumnSpec(
-        name=ColName.NUM_GIH_WON,
+    ColName.NUM_GIH_WON: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_OPENING_HAND) + pl.col(ColName.WON_DRAWN),
     ),
-    ColumnSpec(
-        name=ColName.GIH_WR,
+    ColName.GIH_WR: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.NUM_GIH_WON) / pl.col(ColName.NUM_GIH),
     ),
-    ColumnSpec(
-        name=ColName.GNS_WR,
+    ColName.GNS_WR: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_NUM_GNS) / pl.col(ColName.NUM_GNS),
     ),
-    ColumnSpec(
-        name=ColName.IWD,
+    ColName.IWD: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.GIH_WR) - pl.col(ColName.GNS_WR),
     ),
-    ColumnSpec(
-        name=ColName.NUM_IN_POOL,
+    ColName.NUM_IN_POOL: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK) + pl.col(ColName.SIDEBOARD),
     ),
-    ColumnSpec(
-        name=ColName.IN_POOL_WR,
+    ColName.IN_POOL_WR: ColSpec(
         col_type=ColType.AGG,
         expr=(pl.col(ColName.WON_DECK) + pl.col(ColName.WON_SIDEBOARD))
         / pl.col(ColName.NUM_IN_POOL),
     ),
-    ColumnSpec(
-        name=ColName.DECK_TOTAL,
+    ColName.DECK_TOTAL: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK).sum(),
     ),
-    ColumnSpec(
-        name=ColName.WON_DECK_TOTAL,
+    ColName.WON_DECK_TOTAL: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_DECK).sum(),
     ),
-    ColumnSpec(
-        name=ColName.GP_WR_MEAN,
+    ColName.GP_WR_MEAN: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_DECK_TOTAL) / pl.col(ColName.DECK_TOTAL),
     ),
-    ColumnSpec(
-        name=ColName.GP_WR_EXCESS,
+    ColName.GP_WR_EXCESS: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.GP_WR) - pl.col(ColName.GP_WR_MEAN),
     ),
-    ColumnSpec(
-        name=ColName.GP_WR_VAR,
+    ColName.GP_WR_VAR: ColSpec(
         col_type=ColType.AGG,
         expr=(pl.col(ColName.GP_WR_EXCESS).pow(2) * pl.col(ColName.NUM_GP)).sum()
         / pl.col(ColName.DECK_TOTAL),
     ),
-    ColumnSpec(
-        name=ColName.GP_WR_STDEV,
+    ColName.GP_WR_STDEV: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.GP_WR_VAR).sqrt(),
     ),
-    ColumnSpec(
-        name=ColName.GP_WR_Z,
+    ColName.GP_WR_Z: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.GP_WR_EXCESS) / pl.col(ColName.GP_WR_STDEV),
     ),
-    ColumnSpec(
-        name=ColName.GIH_TOTAL,
+    ColName.GIH_TOTAL: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.NUM_GIH).sum(),
     ),
-    ColumnSpec(
-        name=ColName.WON_GIH_TOTAL,
+    ColName.WON_GIH_TOTAL: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.NUM_GIH_WON).sum(),
     ),
-    ColumnSpec(
-        name=ColName.GIH_WR_MEAN,
+    ColName.GIH_WR_MEAN: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_GIH_TOTAL) / pl.col(ColName.GIH_TOTAL),
     ),
-    ColumnSpec(
-        name=ColName.GIH_WR_EXCESS,
+    ColName.GIH_WR_EXCESS: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.GIH_WR) - pl.col(ColName.GIH_WR_MEAN),
     ),
-    ColumnSpec(
-        name=ColName.GIH_WR_VAR,
+    ColName.GIH_WR_VAR: ColSpec(
         col_type=ColType.AGG,
         expr=(pl.col(ColName.GIH_WR_EXCESS).pow(2) * pl.col(ColName.NUM_GIH)).sum()
         / pl.col(ColName.GIH_TOTAL),
     ),
-    ColumnSpec(
-        name=ColName.GIH_WR_STDEV,
+    ColName.GIH_WR_STDEV: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.GIH_WR_VAR).sqrt(),
     ),
-    ColumnSpec(
-        name=ColName.GIH_WR_Z,
+    ColName.GIH_WR_Z: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.GIH_WR_EXCESS) / pl.col(ColName.GIH_WR_STDEV),
     ),
-    ColumnSpec(
-        name=ColName.DECK_MANA_VALUE_AVG,
+    ColName.DECK_MANA_VALUE_AVG: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK_MANA_VALUE) / pl.col(ColName.DECK_SPELLS),
     ),
-    ColumnSpec(
-        name=ColName.DECK_LANDS_AVG,
+    ColName.DECK_LANDS_AVG: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK_LANDS) / pl.col(ColName.NUM_GAMES),
     ),
-    ColumnSpec(
-        name=ColName.DECK_SPELLS_AVG,
+    ColName.DECK_SPELLS_AVG: ColSpec(
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK_SPELLS) / pl.col(ColName.NUM_GAMES),
     ),
-]
-
-col_spec_map = {col.name: col for col in _column_specs}
+}
 
 for item in ColName:
-    assert item in col_spec_map, f"column {item} enumerated but not specified"
+    assert item in specs, f"column {item} enumerated but not specified"

spells/draft_data.py

@@ -14,12 +14,13 @@ from inspect import signature
 from typing import Callable, TypeVar, Any
 
 import polars as pl
+from polars.exceptions import ColumnNotFoundError
 
 from spells.external import data_file_path
 import spells.cache
 import spells.filter
 import spells.manifest
-from spells.columns import ColumnDefinition, ColumnSpec
+from spells.columns import ColDef, ColSpec
 from spells.enums import View, ColName, ColType
 
 
@@ -53,8 +54,8 @@ def _get_names(set_code: str) -> list[str]:
     return names
 
 
-def _get_card_context(set_code: str, col_spec_map: dict[str, ColumnSpec]) -> dict[str, dict[str, Any]]:
-    card_attr_specs = {col:spec for col, spec in col_spec_map.items() if spec.col_type == ColType.CARD_ATTR or spec.name == ColName.NAME}
+def _get_card_context(set_code: str, specs: dict[str, ColSpec], card_context: pl.DataFrame | dict[str, dict[str, Any]] | None) -> dict[str, dict[str, Any]]:
+    card_attr_specs = {col:spec for col, spec in specs.items() if spec.col_type == ColType.CARD_ATTR or col == ColName.NAME}
     col_def_map = _hydrate_col_defs(set_code, card_attr_specs, card_only=True)
 
     columns = list(col_def_map.keys())
@@ -65,12 +66,25 @@ def _get_card_context(set_code: str, col_spec_map: dict[str, ColumnSpec]) -> dic
         card_df, frozenset(columns), col_def_map, is_agg_view=False
     ).to_dicts()
 
-    card_context = {row[ColName.NAME]: row for row in select_rows}
+    loaded_context = {row[ColName.NAME]: row for row in select_rows}
 
-    return card_context
+    if card_context is not None:
+        if isinstance(card_context, pl.DataFrame):
+            try:
+                card_context = {row[ColName.NAME]: row for row in card_context.to_dicts()}
+            except ColumnNotFoundError:
+                raise ValueError("card_context DataFrame must have column 'name'")
+
+        names = list(loaded_context.keys())
+        for name in names:
+            assert name in card_context, f"card_context must include a row for each card name. {name} missing."
+            for col, value in card_context[name].items():
+                loaded_context[name][col] = value
+
+    return loaded_context
     
 
-def _determine_expression(spec: ColumnSpec, names: list[str], card_context: dict[str, dict]) -> pl.Expr | tuple[pl.Expr, ...]:
+def _determine_expression(col: str, spec: ColSpec, names: list[str], card_context: dict[str, dict]) -> pl.Expr | tuple[pl.Expr, ...]:
     def seed_params(expr):
         params = {}
 
@@ -83,18 +97,18 @@ def _determine_expression(spec: ColumnSpec, names: list[str], card_context: dict
 
     if spec.col_type == ColType.NAME_SUM:
         if spec.expr is not None:
-            assert isinstance(spec.expr, Callable), f"NAME_SUM column {spec.name} must have a callable `expr` accepting a `name` argument"
+            assert isinstance(spec.expr, Callable), f"NAME_SUM column {col} must have a callable `expr` accepting a `name` argument"
             unnamed_exprs = [spec.expr(**{'name': name, **seed_params(spec.expr)}) for name in names]
 
             expr = tuple(
                 map(
-                    lambda ex, name: ex.alias(f"{spec.name}_{name}"),
+                    lambda ex, name: ex.alias(f"{col}_{name}"),
                     unnamed_exprs,
                     names,
                 )
             )
         else:
-            expr = tuple(map(lambda name: pl.col(f"{spec.name}_{name}"), names))
+            expr = tuple(map(lambda name: pl.col(f"{col}_{name}"), names))
 
     elif spec.expr is not None:
         if isinstance(spec.expr, Callable):
@@ -104,25 +118,27 @@ def _determine_expression(spec: ColumnSpec, names: list[str], card_context: dict
                 for name in names:
                     name_params = {'name': name, **params}
                     expr = pl.when(pl.col(ColName.PICK) == name).then(spec.expr(**name_params)).otherwise(expr)
+            elif spec.col_type == ColType.CARD_ATTR and 'name' in signature(spec.expr).parameters:
+                expr = spec.expr(**{'name': pl.col('name'), **params})
             else:
                 expr = spec.expr(**params)
         else:
             expr = spec.expr
-        expr = expr.alias(spec.name)
+        expr = expr.alias(col)
     else:
-        expr = pl.col(spec.name)
+        expr = pl.col(col)
 
     return expr
 
 
-def _infer_dependencies(name: str, expr: pl.Expr | tuple[pl.Expr,...], col_spec_map: dict[str, ColumnSpec], names: list[str]) -> set[str]:
+def _infer_dependencies(name: str, expr: pl.Expr | tuple[pl.Expr,...], specs: dict[str, ColSpec], names: list[str]) -> set[str]:
     dependencies = set()
     tricky_ones = set()
 
     if isinstance(expr, pl.Expr):
         dep_cols = [c for c in expr.meta.root_names() if c != name]
         for dep_col in dep_cols:
-            if dep_col in col_spec_map.keys():
+            if dep_col in specs.keys():
                 dependencies.add(dep_col)
             else: 
                 tricky_ones.add(dep_col)
@@ -131,9 +147,9 @@ def _infer_dependencies(name: str, expr: pl.Expr | tuple[pl.Expr,...], col_spec_
             pattern = f"_{names[idx]}$"
             dep_cols = [c for c in exp.meta.root_names() if c != name]
             for dep_col in dep_cols:
-                if dep_col in col_spec_map.keys():
+                if dep_col in specs.keys():
                     dependencies.add(dep_col)
-                elif len(split := re.split(pattern, dep_col)) == 2 and split[0] in col_spec_map:
+                elif len(split := re.split(pattern, dep_col)) == 2 and split[0] in specs:
                     dependencies.add(split[0])
                 else:
                     tricky_ones.add(dep_col)
@@ -142,7 +158,7 @@ def _infer_dependencies(name: str, expr: pl.Expr | tuple[pl.Expr,...], col_spec_
         found = False
         for n in names:
             pattern = f"_{n}$"
-            if not found and len(split := re.split(pattern, item)) == 2 and split[0] in col_spec_map:
+            if not found and len(split := re.split(pattern, item)) == 2 and split[0] in specs:
                 dependencies.add(split[0])
                 found = True
         assert found, f"Could not locate column spec for root col {item}" 
@@ -150,56 +166,57 @@ def _infer_dependencies(name: str, expr: pl.Expr | tuple[pl.Expr,...], col_spec_
     return dependencies
 
 
-def _hydrate_col_defs(set_code: str, col_spec_map: dict[str, ColumnSpec], card_only=False):
+def _hydrate_col_defs(set_code: str, specs: dict[str, ColSpec], card_context: pl.DataFrame | dict[str, dict] | None = None, card_only: bool =False):
     names = _get_names(set_code)
 
     if card_only:
         card_context = {}
     else:
-        card_context = _get_card_context(set_code, col_spec_map)
+        card_context = _get_card_context(set_code, specs, card_context)
 
     assert len(names) > 0, "there should be names"
     hydrated = {}
-    for key, spec in col_spec_map.items():
-        expr = _determine_expression(spec, names, card_context)
-        dependencies = _infer_dependencies(key, expr, col_spec_map, names)
+    for col, spec in specs.items():
+        expr = _determine_expression(col, spec, names, card_context)
+        dependencies = _infer_dependencies(col, expr, specs, names)
 
+        sig_expr = expr if isinstance(expr, pl.Expr) else expr[0]
         try:
-            sig_expr = expr if isinstance(expr, pl.Expr) else expr[0]
             expr_sig = sig_expr.meta.serialize(
                 format="json"
-            )  # not compatible with renaming
+            )
         except pl.exceptions.ComputeError:
             if spec.version is not None:
-                expr_sig = spec.name + spec.version
+                expr_sig = col + spec.version
             else:
-                expr_sig = str(datetime.datetime.now)
+                print(f"Using session-only signature for non-serializable column {col}, please provide a version value")
+                expr_sig = str(sig_expr)
 
         signature = str(
             (
-                spec.name,
+                col,
                 spec.col_type.value,
                 expr_sig,
-                dependencies,
+                sorted(dependencies),
             )
         )
 
-        cdef = ColumnDefinition(
-            name=spec.name,
+        cdef = ColDef(
+            name=col,
             col_type=spec.col_type,
             views=set(spec.views or set()),
             expr=expr,
             dependencies=dependencies,
             signature=signature,
         )
-        hydrated[key] = cdef
+        hydrated[col] = cdef
     return hydrated
 
 
 def _view_select(
     df: DF,
     view_cols: frozenset[str],
-    col_def_map: dict[str, ColumnDefinition],
+    col_def_map: dict[str, ColDef],
     is_agg_view: bool,
 ) -> DF:
     base_cols = frozenset()
@@ -339,17 +356,18 @@ def summon(
     columns: list[str] | None = None,
     group_by: list[str] | None = None,
     filter_spec: dict | None = None,
-    extensions: list[ColumnSpec] | None = None,
+    extensions: dict[str, ColSpec] | None = None,
     use_streaming: bool = False,
     read_cache: bool = True,
     write_cache: bool = True,
+    card_context: pl.DataFrame | dict[str, dict] | None = None
 ) -> pl.DataFrame:
-    col_spec_map = dict(spells.columns.col_spec_map)
+    specs = dict(spells.columns.specs)
+
     if extensions is not None:
-        for spec in extensions:
-            col_spec_map[spec.name] = spec
+        specs.update(extensions)
 
-    col_def_map = _hydrate_col_defs(set_code, col_spec_map)
+    col_def_map = _hydrate_col_defs(set_code, specs, card_context)
     m = spells.manifest.create(col_def_map, columns, group_by, filter_spec)
 
     calc_fn = functools.partial(_base_agg_df, set_code, m, use_streaming=use_streaming)

spells/enums.py

@@ -60,6 +60,7 @@ class ColName(StrEnum):
     PICK_NUM = "pick_num"  # pick_number plus 1
     TAKEN_AT = "taken_at"
     NUM_TAKEN = "num_taken"
+    NUM_DRAFTS = "num_drafts"
     PICK = "pick"
     PICK_MAINDECK_RATE = "pick_maindeck_rate"
     PICK_SIDEBOARD_IN_RATE = "pick_sideboard_in_rate"

spells/extension.py

@@ -0,0 +1,40 @@
+import polars as pl
+
+from spells.enums import ColType
+from spells.columns import ColSpec
+
+def attr_metrics(attr):
+    return {
+        f"seen_{attr}": ColSpec(
+            col_type=ColType.NAME_SUM,
+            expr=(lambda name, card_context: pl.when(pl.col(f"pack_card_{name}") > 0)
+                .then(card_context[name][attr])
+                .otherwise(None)),
+        ),
+        f"pick_{attr}": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=lambda name, card_context: card_context[name][attr]
+        ),
+        f"least_{attr}_taken": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=(lambda names: pl.col(f'pick_{attr}')
+                <= pl.min_horizontal([pl.col(f"seen_{attr}_{name}") for name in names])),
+        ),
+        f"least_{attr}_taken_rate": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"least_{attr}_taken") / pl.col("num_taken"), 
+        ),
+        f"greatest_{attr}_taken": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=(lambda names: pl.col(f'pick_{attr}')
+                >= pl.max_horizontal([pl.col(f"seen_{attr}_{name}") for name in names])),
+        ),
+        f"greatest_{attr}_taken_rate": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"greatest_{attr}_taken") / pl.col("num_taken"), 
+        ),
+        f"pick_{attr}_mean": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"pick_{attr}") / pl.col("num_taken")
+        )
+    }

spells/manifest.py

@@ -3,13 +3,13 @@ from dataclasses import dataclass
 import spells.columns
 import spells.filter
 from spells.enums import View, ColName, ColType
-from spells.columns import ColumnDefinition
+from spells.columns import ColDef
 
 
 @dataclass(frozen=True)
 class Manifest:
     columns: tuple[str, ...]
-    col_def_map: dict[str, ColumnDefinition]
+    col_def_map: dict[str, ColDef]
     base_view_group_by: frozenset[str]
     view_cols: dict[View, frozenset[str]]
     group_by: tuple[str, ...]
@@ -85,7 +85,7 @@ class Manifest:
 
 def _resolve_view_cols(
     col_set: frozenset[str],
-    col_def_map: dict[str, ColumnDefinition],
+    col_def_map: dict[str, ColDef],
 ) -> dict[View, frozenset[str]]:
     """
     For each view ('game', 'draft', and 'card'), return the columns
@@ -153,7 +153,7 @@ def _resolve_view_cols(
 
 
 def create(
-    col_def_map: dict[str, ColumnDefinition],
+    col_def_map: dict[str, ColDef],
     columns: list[str] | None = None,
     group_by: list[str] | None = None,
     filter_spec: dict | None = None,

{spells_mtg-0.4.0.dist-info → spells_mtg-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spells-mtg
-Version: 0.4.0
+Version: 0.5.1
 Summary: analaysis of 17Lands.com public datasets
 Author-Email: Joel Barnes <oelarnes@gmail.com>
 License: MIT
@@ -74,8 +74,9 @@ Spells is not affiliated with 17Lands. Please review the [Usage Guidelines](http
 - Supports calculating the standard aggregations and measures out of the box with no arguments (ALSA, GIH WR, etc)
 - Caches aggregate DataFrames in the local file system automatically for instantaneous reproduction of previous analysis
 - Manages grouping and filtering by built-in and custom columns at the row level
-- Provides 121 explicitly specified, enumerated, documented column definitions
+- Provides 122 explicitly specified, enumerated, documented column definitions
 - Supports "Deck Color Data" aggregations with built-in column definitions.
+- Lets you feed card metrics back in to column definitions to support scientific workflows like MLE
 - Provides a CLI tool `spells [add|refresh|clean|remove|info] [SET]` to download and manage external files
 - Downloads and manages public datasets from 17Lands
 - Retrieves and models booster configuration and card data from [MTGJSON](https://mtgjson.com/)
@@ -87,7 +88,7 @@ Spells is not affiliated with 17Lands. Please review the [Usage Guidelines](http
 
 ## summon
 
-`summon` takes four optional arguments, allowing a fully declarative specification of your desired analysis. Basic functionality not provided by this api can often be managed by simple chained calls using the polars API, e.g. sorting and post-agg filtering.
+`summon` takes five optional arguments, allowing a fully declarative specification of your desired analysis. Basic functionality not provided by this api can often be managed by simple chained calls using the polars API, e.g. sorting and post-agg filtering.
   - `columns` specifies the desired output columns
     ```python
     >>> spells.summon('DSK', columns=["num_gp", "pct_gp", "gp_wr", "gp_wr_z"])
@@ -133,7 +134,7 @@ Spells is not affiliated with 17Lands. Please review the [Usage Guidelines](http
     ```
   - `filter_spec` specifies a row-level filter for the dataset, using an intuitive custom query formulation
     ```python
-    >>> from spells.enums import ColName
+    >>> from spells import ColName
     >>> spells.summon('BLB', columns=[ColName.GAME_WR], group_by=[ColName.PLAYER_COHORT], filter_spec={'lhs': ColName.NUM_MULLIGANS, 'op': '>', 'rhs': 0})
     shape: (4, 2)
     ┌───────────────┬──────────┐
@@ -150,14 +151,14 @@ Spells is not affiliated with 17Lands. Please review the [Usage Guidelines](http
   - `extensions` allows for the specification of arbitrarily complex derived columns and aggregations, including custom columns built on top of custom columns.
     ```python
     >>> import polars as pl
-    >>> from spells.columns import ColumnSpec
-    >>> from spells.enums import ColType, View, ColName
-    >>> ext = ColumnSpec(
-    ...     name='deq_base',
-    ...     col_type=ColType.AGG,
-    ...     expr=(pl.col('gp_wr_excess') + 0.03 * (1 - pl.col('ata')/14).pow(2)) * pl.col('pct_gp'),
-    ... )
-    >>> spells.summon('DSK', columns=['deq_base', 'color', 'rarity'], filter_spec={'player_cohort': 'Top'}, extensions=[ext])
+    >>> from spells import ColSpec, ColType 
+    >>> ext = {
+    ...     'deq_base': ColSpec(
+    ...         col_type=ColType.AGG,
+    ...         expr=(pl.col('gp_wr_excess') + 0.03 * (1 - pl.col('ata')/14).pow(2)) * pl.col('pct_gp'),
+    ...     }
+    ... }
+    >>> spells.summon('DSK', columns=['deq_base', 'color', 'rarity'], filter_spec={'player_cohort': 'Top'}, extensions=ext)
     ...     .filter(pl.col('deq_base').is_finite())
     ...     .filter(pl.col('rarity').is_in(['common', 'uncommon'])
     ...     .sort('deq_base', descending=True)
@@ -180,8 +181,32 @@ Spells is not affiliated with 17Lands. Please review the [Usage Guidelines](http
     │ Oblivious Bookworm       ┆ 0.028605 ┆ uncommon ┆ GU    │
     └──────────────────────────┴──────────┴──────────┴───────┘
     ```
-    
-    Note the use of chained calls to the Polars DataFrame api to perform manipulations on the result of `summon`.
+  - `card_context` takes a name-indexed DataFrame or name-keyed dict and allows the construction of column definitions based on the results.
+    ```python
+    >>> deq = spells.summon('DSK', columns=['deq_base'], filter_spec={'player_cohort': 'Top'}, extensions=[ext])
+    >>> ext = { 
+    ...     'picked_deq_base': ColSpec(
+    ...         col_type=ColType.PICK_SUM,
+    ...         expr=lambda name, card_context: card_context[name]['deq_base']
+    ...     ),
+    ...     'picked_deq_base_avg', ColSpec(
+    ...         col_type=ColType.AGG,
+    ...         expr=pl.col('picked_deq_base') / pl.col('num_taken')
+    ...     ),
+    ... }
+    >>> spells.summon('DSK', columns=['picked_deq_base_avg'], group_by=['player_cohort'], extensions=ext, card_context=deq)
+    shape: (4, 2)
+    ┌───────────────┬─────────────────────┐
+    │ player_cohort ┆ picked_deq_base_avg │
+    │ ---           ┆ ---                 │
+    │ str           ┆ f64                 │
+    ╞═══════════════╪═════════════════════╡
+    │ Bottom        ┆ 0.004826            │
+    │ Middle        ┆ 0.00532             │
+    │ Other         ┆ 0.004895            │
+    │ Top           ┆ 0.005659            │
+    └───────────────┴─────────────────────┘
+    ```
     
 ## Installation
 
@@ -223,7 +248,7 @@ Spells caches the results of expensive aggregations in the local file system as
 
 ### Memory Usage
 
-One of my goals in creating Spells was to eliminate issues with memory pressure by exclusively using the map-reduce paradigm and a technology that supports partitioned/streaming aggregation of larget-than-memory datasets. By default, Polars loads the entire dataset in memory, but the API exposes a parameter `streaming` which I have exposed as `use_streaming`. Unfortunately, that feature does not seem to work for my queries and the memory performance can be quite poor, including poor garbage collection. The one feature that may assist in memory management is the local caching, since you can restart the kernel without losing all of your progress. In particular, be careful about opening multiple Jupyter tabs unless you have at least 32 GB. In general I have not run into issues on my 16 GB MacBook Air except with running multiple kernels at once. Supporting larger-than memory computations is on my roadmap, so check back periodically to see if I've made any progress.
+One of my goals in creating Spells was to eliminate issues with memory pressure by exclusively using the map-reduce paradigm and a technology that supports partitioned/streaming aggregation of larget-than-memory datasets. By default, Polars loads the entire dataset in memory, but the API exposes a parameter `streaming` which I have exposed as `use_streaming`. Unfortunately, that feature does not seem to work for my queries and the memory performance can be quite poor. The one feature that may assist in memory management is the local caching, since you can restart the kernel without losing all of your progress. In particular, be careful about opening multiple Jupyter tabs unless you have at least 32 GB. In general I have not run into issues on my 16 GB MacBook Air except with running multiple kernels at once. Supporting larger-than memory computations is on my roadmap, so check back periodically to see if I've made any progress.
 
 When refreshing a given set's data files from 17Lands using the provided cli, the cache for that set is automatically cleared. The `spells` CLI gives additional tools for managing the local and external caches.
 
@@ -289,25 +314,26 @@ aggregations of non-numeric (or numeric) data types are not supported. If `None`
     - `{'lhs': 'player_cohort', 'op': 'in', 'rhs': ['Top', 'Middle']}` "player_cohort" value is either "Top" or "Middle". Supported values for `op` are `<`, `<=`, `>`, `>=`, `!=`, `=`, `in` and `nin`.
     - `{'$and': [{'lhs': 'draft_date', 'op': '>', 'rhs': datetime.date(2024, 10, 7)}, {'rank': 'Mythic'}]}` Drafts after October 7 by Mythic-ranked players. Supported values for query construction keys are `$and`, `$or`, and `$not`.
 
-- extensions: a list of `spells.columns.ColumnSpec` objects, which are appended to the definitions built-in columns described below. A name not in the enum `ColName` can be used in this way if it is the name of a provided extension. Existing names can also be redefined using extensions.
+- extensions: a dict of `spells.columns.ColSpec` objects, keyed by name, which are appended to the definitions built-in columns described below. 
+
+- card_context: Typically a Polars DataFrame containing a `"name"` column with one row for each card name in the set, such that any usages of `card_context[name][key]` in column specs reference the column `key`. Typically this will be the output of a call to `summon` requesting cards metrics like `GP_WR`. Can also be a dictionary having the necessary form for the same access pattern.
 
 - read_cache/write_cache: Use the local file system to cache and retrieve aggregations to minimize expensive reads of the large datasets. You shouldn't need to touch these arguments unless you are debugging.
 
 ### Enums
 
 ```python
-from spells.enums import ColName, ColType
+from spells import ColName, ColType
 ```
 
 Recommended to import `ColName` for any usage of `summon`, and to import `ColType` when defining custom extensions.
 
-### ColumnSpec
+### ColSpec
 
 ```python
-from spells.columns import ColumnSpec
+from spells import ColSpec
 
-ColumnSpec(
-    name: str,
+ColSpec(
     col_type: ColType,
     expr: pl.Expr | Callable[..., pl.Expr] | None = None,
     version: str | None = None
@@ -318,8 +344,6 @@ Used to define extensions in `summon`
 
 #### parameters
 
-- `name`: any string, including existing columns, although this is very likely to break dependent columns, so don't do it. For `NAME_SUM` columns, the name is the prefix without the underscore, e.g. "drawn".
-
 - `col_type`: one of the `ColType` enum values, `FILTER_ONLY`, `GROUP_BY`, `PICK_SUM`, `NAME_SUM`, `GAME_SUM`, `CARD_ATTR`, and `AGG`. See documentation for `summon` for usage. All columns except `CARD_ATTR`
 and `AGG` must be derivable at the individual row level on one or both base views. `CARD_ATTR` must be derivable at the individual row level from the card file. `AGG` can depend on any column present after 
 summing over groups, and can include polars Expression aggregations. Arbitrarily long chains of aggregate dependencies are supported.
@@ -328,7 +352,7 @@ summing over groups, and can include polars Expression aggregations. Arbitrarily
     - For `NAME_SUM` columns, `expr` must be a function of `name` which will result in a list of expressions mapped over all card names.
     - `PICK_SUM` columns can also be functions on `name`, in which case the value will be a function of the value of the `PICK` field. 
     - `AGG` columns that depend on `NAME_SUM` columns reference the prefix (`cdef.name`) only, since the unpivot has occured prior to selection. 
-    - The possible arguments to `expr`, in addition to `name` when appropriate, include the full `names` array as well as a dictionary called `card_context` which contains card dict objects with all `CARD_ATTR` values, including custom extensions. See example notebooks for more details.
+    - The possible arguments to `expr`, in addition to `name` when appropriate, include the full `names` array as well as a dictionary called `card_context` which contains card dict objects with all `CARD_ATTR` values, including custom extensions and metric columns passed by the `card_context` argument to `summon`. See example notebooks for more details.
 
 - `version`: When defining a column using a python function, as opposed to Polars expressions, add a unique version number so that the unique hashed signature of the column specification can be derived 
 for caching purposes, since Polars cannot generate a serialization natively. When changing the definition, be sure to increment the version value. Otherwise you do not need to use this parameter.
@@ -366,6 +390,7 @@ A table of all included columns. Columns can be referenced by enum or by string
 | `PICK_NUMBER`            | `"pick_number"`            | `DRAFT` | `FILTER_ONLY` | Dataset Column                               | Int      |
 | `PICK_NUM`               | `"pick_num"`               | `DRAFT` | `GROUP_BY`    | 1-indexed                                    | Int      |
 | `TAKEN_AT`               | `"taken_at`                | `DRAFT` | `PICK_SUM`    | Summable alias of `PICK_NUM`                 | Int      |
+| `NUM_DRAFTS`           | `"num_drafts"` | `DRAFT` | `PICK_SUM` | | Int |
 | `NUM_TAKEN`              | `"num_taken"`              | `DRAFT` | `PICK_SUM`    | Sum 1 over rows                              | Int      |
 | `PICK`                   | `"pick"`                   | `DRAFT` | `FILTER_ONLY` | Dataset Column, joined as "name"             | String   |
 | `PICK_MAINDECK_RATE`     | `"pick_maindeck_rate"`     | `DRAFT` | `PICK_SUM`    | Dataset Column                               | Float    |

spells_mtg-0.5.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+spells/__init__.py,sha256=iyX74sLFJIQ_5ShZ7KDOeBlbYLm21ibWxwyzCGnKdg8,169
+spells/cache.py,sha256=4v7h8D3TtaT0R_EdiRNhdcQrXzdH_CukezO6oAXvNEY,2956
+spells/cards.py,sha256=EOXAB_F2yedjf6KquCERCIHl0TSIJIoOe1jv8g4JzOc,3601
+spells/columns.py,sha256=D4dcXVfXlXIbOE2CDgXhGCCYLhUK_XLu4lzm677tj2c,17264
+spells/draft_data.py,sha256=viulqB_kaWHYgEtGrzQ5ZVf2jBau9kfnWwJAcP678Jw,13471
+spells/enums.py,sha256=2IZrty0OtcbXq8oiuDWF75_AacMBBY_JLaisc_bNSdk,4765
+spells/extension.py,sha256=B9U1HvPAVqE0g44sihS6EGlkEtTx2VOrcWtg5fPh-mw,1482
+spells/external.py,sha256=qe6wOBDhPN4CZNQvYRq6G-OpIZcWTZzJjySgnf2Gu1o,10258
+spells/filter.py,sha256=J-YTOOAzOQpvIX29tviYL04RVoOUlfsbjBXoQBDCEdQ,3380
+spells/manifest.py,sha256=UNCZT3StN_1DfYfWNuEQrQx7ZI8Z5Y_l6j2oaUaWdYA,8142
+spells/schema.py,sha256=z8Qn2SiHG4T6YfPsz8xHLGMjU_Ofm76-Vrquh3b9B64,6422
+spells_mtg-0.5.1.dist-info/METADATA,sha256=tr4oUQAo5bJlL1IIKJHDj9EM_bH1PEiHSbKj8NLWelU,45452
+spells_mtg-0.5.1.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+spells_mtg-0.5.1.dist-info/entry_points.txt,sha256=a9Y1omdl9MdnKuIj3aOodgrp-zZII6OCdvqwgP6BFvI,63
+spells_mtg-0.5.1.dist-info/licenses/LICENSE,sha256=tS54XYbJSgmq5zuHhbsQGbNQLJPVgXqhF5nu2CSRMig,1068
+spells_mtg-0.5.1.dist-info/RECORD,,

spells_mtg-0.4.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-spells/__init__.py,sha256=EcI7ijXYvPA8jj7wUZqs6CSWr__MD8AOXhkex-Hj37E,131
-spells/cache.py,sha256=4v7h8D3TtaT0R_EdiRNhdcQrXzdH_CukezO6oAXvNEY,2956
-spells/cards.py,sha256=EOXAB_F2yedjf6KquCERCIHl0TSIJIoOe1jv8g4JzOc,3601
-spells/columns.py,sha256=gpgx8zZ4VmmcJXxMdyEKIOgJaBESKkbtpOm6bVNNopM,19132
-spells/draft_data.py,sha256=bJw2ueJ1dNrunVY2GH6pgJCMPFCkydI37JExgpMS6vE,12559
-spells/enums.py,sha256=4G-gi75v9bne4cMRgRwwmpWy0kW8NoTjkmGTxEwFDeo,4735
-spells/external.py,sha256=qe6wOBDhPN4CZNQvYRq6G-OpIZcWTZzJjySgnf2Gu1o,10258
-spells/filter.py,sha256=J-YTOOAzOQpvIX29tviYL04RVoOUlfsbjBXoQBDCEdQ,3380
-spells/manifest.py,sha256=Dy0zskkSqPWb3WQqLgNk5pbaCGlEAn7JG9wRFOUA3Jc,8182
-spells/schema.py,sha256=z8Qn2SiHG4T6YfPsz8xHLGMjU_Ofm76-Vrquh3b9B64,6422
-spells_mtg-0.4.0.dist-info/METADATA,sha256=pEKOk-A27Tq8Fpbs9yPb11tT9av4f7-iOQSIGfWv9Mg,43908
-spells_mtg-0.4.0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-spells_mtg-0.4.0.dist-info/entry_points.txt,sha256=a9Y1omdl9MdnKuIj3aOodgrp-zZII6OCdvqwgP6BFvI,63
-spells_mtg-0.4.0.dist-info/licenses/LICENSE,sha256=tS54XYbJSgmq5zuHhbsQGbNQLJPVgXqhF5nu2CSRMig,1068
-spells_mtg-0.4.0.dist-info/RECORD,,