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

spells/__init__.py

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

spells/cards.py

@@ -76,7 +76,10 @@ def _extract_value(set_code: str, name: str, card_dict: dict, field: CardAttr):
 
 def card_df(draft_set_code: str, names: list[str]) -> pl.DataFrame:
     draft_set_json = _fetch_mtg_json(draft_set_code)
-    set_codes = draft_set_json["data"]["booster"]["play"]["sourceSetCodes"]
+    booster_info = draft_set_json["data"]["booster"]
+
+    booster_type = "play" if "play" in booster_info else "draft"
+    set_codes = booster_info[booster_type]["sourceSetCodes"]
     set_codes.reverse()
 
     card_data_map = {}

spells/columns.py

@@ -10,13 +10,9 @@ from spells.enums import View, ColName, ColType
 class ColumnSpec:
     name: str
     col_type: ColType
-    expr: pl.Expr | None = None
-    exprMap: Callable[[str], pl.Expr] | None = None
+    expr: pl.Expr | Callable[..., pl.Expr] | None = None
     views: list[View] | None = None
-    dependencies: list[str] | None = None
-    version: str | None = (
-        None  # only needed for user-defined functions with python functions in expr
-    )
+    version: str | None = None
 
 
 @dataclass(frozen=True)
@@ -25,7 +21,7 @@ class ColumnDefinition:
     col_type: ColType
     expr: pl.Expr | tuple[pl.Expr, ...]
     views: set[View]
-    dependencies: tuple[str, ...]
+    dependencies: set[str]
     signature: str
 
 
@@ -49,7 +45,7 @@ _column_specs = [
     ColumnSpec(
         name=ColName.NAME,
         col_type=ColType.GROUP_BY,
-        # handled by internals, derived from both 'pick' and "name mapped" columns
+        views=[View.CARD],
     ),
     ColumnSpec(
         name=ColName.EXPANSION,
@@ -74,26 +70,22 @@ _column_specs = [
     ColumnSpec(
         name=ColName.DRAFT_DATE,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("draft_time").str.to_datetime("%Y-%m-%d %H:%M:%S").dt.date(),
-        dependencies=[ColName.DRAFT_TIME],
+        expr=pl.col(ColName.DRAFT_TIME).str.to_datetime("%Y-%m-%d %H:%M:%S").dt.date(),
     ),
     ColumnSpec(
         name=ColName.DRAFT_DAY_OF_WEEK,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("draft_time").str.to_datetime("%Y-%m-%d %H:%M:%S").dt.weekday(),
-        dependencies=[ColName.DRAFT_TIME],
+        expr=pl.col(ColName.DRAFT_TIME).str.to_datetime("%Y-%m-%d %H:%M:%S").dt.weekday(),
     ),
     ColumnSpec(
         name=ColName.DRAFT_HOUR,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("draft_time").str.to_datetime("%Y-%m-%d %H:%M:%S").dt.hour(),
-        dependencies=[ColName.DRAFT_TIME],
+        expr=pl.col(ColName.DRAFT_TIME).str.to_datetime("%Y-%m-%d %H:%M:%S").dt.hour(),
     ),
     ColumnSpec(
         name=ColName.DRAFT_WEEK,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("draft_time").str.to_datetime("%Y-%m-%d %H:%M:%S").dt.week(),
-        dependencies=[ColName.DRAFT_TIME],
+        expr=pl.col(ColName.DRAFT_TIME).str.to_datetime("%Y-%m-%d %H:%M:%S").dt.week(),
     ),
     ColumnSpec(
         name=ColName.RANK,
@@ -113,18 +105,17 @@ _column_specs = [
     ColumnSpec(
         name=ColName.PLAYER_COHORT,
         col_type=ColType.GROUP_BY,
-        expr=pl.when(pl.col("user_n_games_bucket") < 100)
+        expr=pl.when(pl.col(ColName.USER_N_GAMES_BUCKET) < 100)
         .then(pl.lit("Other"))
         .otherwise(
-            pl.when(pl.col("user_game_win_rate_bucket") > 0.57)
+            pl.when(pl.col(ColName.USER_GAME_WIN_RATE_BUCKET) > 0.57)
             .then(pl.lit("Top"))
             .otherwise(
-                pl.when(pl.col("user_game_win_rate_bucket") < 0.49)
+                pl.when(pl.col(ColName.USER_GAME_WIN_RATE_BUCKET) < 0.49)
                 .then(pl.lit("Bottom"))
                 .otherwise(pl.lit("Middle"))
             )
         ),
-        dependencies=[ColName.USER_N_GAMES_BUCKET, ColName.USER_GAME_WIN_RATE_BUCKET],
     ),
     ColumnSpec(
         name=ColName.EVENT_MATCH_WINS,
@@ -136,7 +127,6 @@ _column_specs = [
         col_type=ColType.PICK_SUM,
         views=[View.DRAFT],
         expr=pl.col(ColName.EVENT_MATCH_WINS),
-        dependencies=[ColName.EVENT_MATCH_WINS],
     ),
     ColumnSpec(
         name=ColName.EVENT_MATCH_LOSSES,
@@ -147,33 +137,28 @@ _column_specs = [
         name=ColName.EVENT_MATCH_LOSSES_SUM,
         col_type=ColType.PICK_SUM,
         expr=pl.col(ColName.EVENT_MATCH_LOSSES),
-        dependencies=[ColName.EVENT_MATCH_LOSSES],
     ),
     ColumnSpec(
         name=ColName.EVENT_MATCHES,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("event_match_wins") + pl.col("event_match_losses"),
-        dependencies=[ColName.EVENT_MATCH_WINS, ColName.EVENT_MATCH_LOSSES],
+        expr=pl.col(ColName.EVENT_MATCH_WINS) + pl.col(ColName.EVENT_MATCH_LOSSES),
     ),
     ColumnSpec(
         name=ColName.EVENT_MATCHES_SUM,
         col_type=ColType.PICK_SUM,
         expr=pl.col(ColName.EVENT_MATCHES),
-        dependencies=[ColName.EVENT_MATCHES],
     ),
     ColumnSpec(
         name=ColName.IS_TROPHY,
         col_type=ColType.GROUP_BY,
-        expr=pl.when(pl.col("event_type") == "Traditional")
-        .then(pl.col("event_match_wins") == 3)
-        .otherwise(pl.col("event_match_wins") == 7),
-        dependencies=[ColName.EVENT_TYPE, ColName.EVENT_MATCH_WINS],
+        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,
         col_type=ColType.PICK_SUM,
         expr=pl.col(ColName.IS_TROPHY),
-        dependencies=[ColName.IS_TROPHY],
     ),
     ColumnSpec(
         name=ColName.PACK_NUMBER,
@@ -183,8 +168,7 @@ _column_specs = [
     ColumnSpec(
         name=ColName.PACK_NUM,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("pack_number") + 1,
-        dependencies=[ColName.PACK_NUMBER],
+        expr=pl.col(ColName.PACK_NUMBER) + 1,
     ),
     ColumnSpec(
         name=ColName.PICK_NUMBER,
@@ -194,26 +178,23 @@ _column_specs = [
     ColumnSpec(
         name=ColName.PICK_NUM,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("pick_number") + 1,
-        dependencies=[ColName.PICK_NUMBER],
+        expr=pl.col(ColName.PICK_NUMBER) + 1,
     ),
     ColumnSpec(
         name=ColName.TAKEN_AT,
         col_type=ColType.PICK_SUM,
         expr=pl.col(ColName.PICK_NUM),
-        dependencies=[ColName.PICK_NUM],
     ),
     ColumnSpec(
         name=ColName.NUM_TAKEN,
         col_type=ColType.PICK_SUM,
         expr=pl.when(pl.col(ColName.PICK).is_not_null())
         .then(1)
-        .otherwise(0),  # a literal returns one row under select alone
-        dependencies=[ColName.PICK],
+        .otherwise(0),
     ),
     ColumnSpec(
         name=ColName.PICK,
-        col_type=ColType.FILTER_ONLY,  # aggregated as "name"
+        col_type=ColType.FILTER_ONLY,
         views=[View.DRAFT],
     ),
     ColumnSpec(
@@ -234,15 +215,13 @@ _column_specs = [
     ColumnSpec(
         name=ColName.LAST_SEEN,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.col(f"pack_card_{name}")
-        * pl.min_horizontal("pick_num", 8),
-        dependencies=[ColName.PACK_CARD, ColName.PICK_NUM],
+        expr=lambda name: pl.col(f"pack_card_{name}")
+        * pl.min_horizontal(ColName.PICK_NUM, 8),
     ),
     ColumnSpec(
         name=ColName.NUM_SEEN,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.col(f"pack_card_{name}") * (pl.col("pick_num") <= 8),
-        dependencies=[ColName.PACK_CARD, ColName.PICK_NUM],
+        expr=lambda name: pl.col(f"pack_card_{name}") * (pl.col(ColName.PICK_NUM) <= 8),
     ),
     ColumnSpec(
         name=ColName.POOL,
@@ -257,26 +236,22 @@ _column_specs = [
     ColumnSpec(
         name=ColName.GAME_DATE,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("game_time").str.to_datetime("%Y-%m-%d %H-%M-%S").dt.date(),
-        dependencies=[ColName.GAME_TIME],
+        expr=pl.col(ColName.GAME_TIME).str.to_datetime("%Y-%m-%d %H-%M-%S").dt.date(),
     ),
     ColumnSpec(
         name=ColName.GAME_DAY_OF_WEEK,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("game_time").str.to_datetime("%Y-%m-%d %H-%M-%S").dt.weekday(),
-        dependencies=[ColName.GAME_TIME],
+        expr=pl.col(ColName.GAME_TIME).str.to_datetime("%Y-%m-%d %H-%M-%S").dt.weekday(),
     ),
     ColumnSpec(
         name=ColName.GAME_HOUR,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("game_time").str.to_datetime("%Y-%m-%d %H-%M-%S").dt.hour(),
-        dependencies=[ColName.GAME_TIME],
+        expr=pl.col(ColName.GAME_TIME).str.to_datetime("%Y-%m-%d %H-%M-%S").dt.hour(),
     ),
     ColumnSpec(
         name=ColName.GAME_WEEK,
         col_type=ColType.GROUP_BY,
-        expr=pl.col("game_time").str.to_datetime("%Y-%m-%d %H-%M-%S").dt.week(),
-        dependencies=[ColName.GAME_TIME],
+        expr=pl.col(ColName.GAME_TIME).str.to_datetime("%Y-%m-%d %H-%M-%S").dt.week(),
     ),
     ColumnSpec(
         name=ColName.BUILD_INDEX,
@@ -297,19 +272,16 @@ _column_specs = [
         name=ColName.NUM_GAMES,
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.GAME_NUMBER).is_not_null(),
-        dependencies=[ColName.GAME_NUMBER],
     ),
     ColumnSpec(
         name=ColName.NUM_MATCHES,
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.GAME_NUMBER) == 1,
-        dependencies=[ColName.GAME_NUMBER],
     ),
     ColumnSpec(
         name=ColName.NUM_EVENTS,
         col_type=ColType.GAME_SUM,
         expr=(pl.col(ColName.GAME_NUMBER) == 1) & (pl.col(ColName.MATCH_NUMBER) == 1),
-        dependencies=[ColName.GAME_NUMBER, ColName.MATCH_NUMBER],
     ),
     ColumnSpec(
         name=ColName.OPP_RANK,
@@ -325,7 +297,6 @@ _column_specs = [
         name=ColName.NUM_COLORS,
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.MAIN_COLORS).str.len_chars(),
-        dependencies=[ColName.MAIN_COLORS],
     ),
     ColumnSpec(
         name=ColName.SPLASH_COLORS,
@@ -336,7 +307,6 @@ _column_specs = [
         name=ColName.HAS_SPLASH,
         col_type=ColType.GROUP_BY,
         expr=pl.col(ColName.SPLASH_COLORS).str.len_chars() > 0,
-        dependencies=[ColName.SPLASH_COLORS],
     ),
     ColumnSpec(
         name=ColName.ON_PLAY,
@@ -347,7 +317,6 @@ _column_specs = [
         name=ColName.NUM_ON_PLAY,
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.ON_PLAY),
-        dependencies=[ColName.ON_PLAY],
     ),
     ColumnSpec(
         name=ColName.NUM_MULLIGANS,
@@ -358,7 +327,6 @@ _column_specs = [
         name=ColName.NUM_MULLIGANS_SUM,
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.NUM_MULLIGANS),
-        dependencies=[ColName.NUM_MULLIGANS],
     ),
     ColumnSpec(
         name=ColName.OPP_NUM_MULLIGANS,
@@ -369,7 +337,6 @@ _column_specs = [
         name=ColName.OPP_NUM_MULLIGANS_SUM,
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.OPP_NUM_MULLIGANS),
-        dependencies=[ColName.OPP_NUM_MULLIGANS],
     ),
     ColumnSpec(
         name=ColName.OPP_COLORS,
@@ -385,7 +352,6 @@ _column_specs = [
         name=ColName.NUM_TURNS_SUM,
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.NUM_TURNS),
-        dependencies=[ColName.NUM_TURNS],
     ),
     ColumnSpec(
         name=ColName.WON,
@@ -396,7 +362,6 @@ _column_specs = [
         name=ColName.NUM_WON,
         col_type=ColType.GAME_SUM,
         expr=pl.col(ColName.WON),
-        dependencies=[ColName.WON],
     ),
     ColumnSpec(
         name=ColName.OPENING_HAND,
@@ -406,8 +371,7 @@ _column_specs = [
     ColumnSpec(
         name=ColName.WON_OPENING_HAND,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.col(f"opening_hand_{name}") * pl.col(ColName.WON),
-        dependencies=[ColName.OPENING_HAND, ColName.WON],
+        expr=lambda name: pl.col(f"opening_hand_{name}") * pl.col(ColName.WON),
     ),
     ColumnSpec(
         name=ColName.DRAWN,
@@ -417,8 +381,7 @@ _column_specs = [
     ColumnSpec(
         name=ColName.WON_DRAWN,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.col(f"drawn_{name}") * pl.col(ColName.WON),
-        dependencies=[ColName.DRAWN, ColName.WON],
+        expr=lambda name: pl.col(f"drawn_{name}") * pl.col(ColName.WON),
     ),
     ColumnSpec(
         name=ColName.TUTORED,
@@ -428,8 +391,7 @@ _column_specs = [
     ColumnSpec(
         name=ColName.WON_TUTORED,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.col(f"tutored_{name}") * pl.col(ColName.WON),
-        dependencies=[ColName.TUTORED, ColName.WON],
+        expr=lambda name: pl.col(f"tutored_{name}") * pl.col(ColName.WON),
     ),
     ColumnSpec(
         name=ColName.DECK,
@@ -439,8 +401,7 @@ _column_specs = [
     ColumnSpec(
         name=ColName.WON_DECK,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.col(f"deck_{name}") * pl.col(ColName.WON),
-        dependencies=[ColName.DECK, ColName.WON],
+        expr=lambda name: pl.col(f"deck_{name}") * pl.col(ColName.WON),
     ),
     ColumnSpec(
         name=ColName.SIDEBOARD,
@@ -450,31 +411,23 @@ _column_specs = [
     ColumnSpec(
         name=ColName.WON_SIDEBOARD,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.col(f"sideboard_{name}") * pl.col(ColName.WON),
-        dependencies=[ColName.SIDEBOARD, ColName.WON],
+        expr=lambda name: pl.col(f"sideboard_{name}") * pl.col(ColName.WON),
     ),
     ColumnSpec(
         name=ColName.NUM_GNS,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.max_horizontal(
+        expr=lambda name: pl.max_horizontal(
             0,
             pl.col(f"deck_{name}")
             - pl.col(f"drawn_{name}")
             - pl.col(f"tutored_{name}")
             - pl.col(f"opening_hand_{name}"),
         ),
-        dependencies=[
-            ColName.DECK,
-            ColName.DRAWN,
-            ColName.TUTORED,
-            ColName.OPENING_HAND,
-        ],
     ),
     ColumnSpec(
         name=ColName.WON_NUM_GNS,
         col_type=ColType.NAME_SUM,
-        exprMap=lambda name: pl.col(ColName.WON) * pl.col(f"num_gns_{name}"),
-        dependencies=[ColName.NUM_GNS, ColName.WON],
+        expr=lambda name: pl.col(ColName.WON) * pl.col(f"num_gns_{name}"),
     ),
     ColumnSpec(
         name=ColName.SET_CODE,
@@ -506,9 +459,18 @@ _column_specs = [
     ),
     ColumnSpec(
         name=ColName.DECK_MANA_VALUE,
-        col_type=ColType.CARD_SUM,
-        expr=pl.col(ColName.MANA_VALUE) * pl.col(ColName.DECK),
-        dependencies=[ColName.MANA_VALUE, ColName.DECK],
+        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,
+        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,
+        col_type=ColType.NAME_SUM,
+        expr=lambda name: pl.col(f"deck_{name}") - pl.col(f"deck_lands_{name}"),
     ),
     ColumnSpec(
         name=ColName.MANA_COST,
@@ -542,196 +504,174 @@ _column_specs = [
         name=ColName.PICKED_MATCH_WR,
         col_type=ColType.AGG,
         expr=pl.col(ColName.EVENT_MATCH_WINS_SUM) / pl.col(ColName.EVENT_MATCHES),
-        dependencies=[ColName.EVENT_MATCH_WINS_SUM, ColName.EVENT_MATCHES],
     ),
     ColumnSpec(
         name=ColName.TROPHY_RATE,
         col_type=ColType.AGG,
         expr=pl.col(ColName.IS_TROPHY_SUM) / pl.col(ColName.NUM_TAKEN),
-        dependencies=[ColName.IS_TROPHY_SUM, ColName.NUM_TAKEN],
     ),
     ColumnSpec(
         name=ColName.GAME_WR,
         col_type=ColType.AGG,
         expr=pl.col(ColName.NUM_WON) / pl.col(ColName.NUM_GAMES),
-        dependencies=[ColName.NUM_WON, ColName.NUM_GAMES],
     ),
     ColumnSpec(
         name=ColName.ALSA,
         col_type=ColType.AGG,
         expr=pl.col(ColName.LAST_SEEN) / pl.col(ColName.NUM_SEEN),
-        dependencies=[ColName.LAST_SEEN, ColName.NUM_SEEN],
     ),
     ColumnSpec(
         name=ColName.ATA,
         col_type=ColType.AGG,
         expr=pl.col(ColName.TAKEN_AT) / pl.col(ColName.NUM_TAKEN),
-        dependencies=[ColName.TAKEN_AT, ColName.NUM_TAKEN],
     ),
     ColumnSpec(
         name=ColName.NUM_GP,
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK),
-        dependencies=[ColName.DECK],
     ),
     ColumnSpec(
         name=ColName.PCT_GP,
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK) / (pl.col(ColName.DECK) + pl.col(ColName.SIDEBOARD)),
-        dependencies=[ColName.DECK, ColName.SIDEBOARD],
     ),
     ColumnSpec(
         name=ColName.GP_WR,
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_DECK) / pl.col(ColName.DECK),
-        dependencies=[ColName.WON_DECK, ColName.DECK],
     ),
     ColumnSpec(
         name=ColName.NUM_OH,
         col_type=ColType.AGG,
         expr=pl.col(ColName.OPENING_HAND),
-        dependencies=[ColName.OPENING_HAND],
     ),
     ColumnSpec(
         name=ColName.OH_WR,
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_OPENING_HAND) / pl.col(ColName.OPENING_HAND),
-        dependencies=[ColName.WON_OPENING_HAND, ColName.OPENING_HAND],
     ),
     ColumnSpec(
         name=ColName.NUM_GIH,
         col_type=ColType.AGG,
         expr=pl.col(ColName.OPENING_HAND) + pl.col(ColName.DRAWN),
-        dependencies=[ColName.OPENING_HAND, ColName.DRAWN],
     ),
     ColumnSpec(
         name=ColName.NUM_GIH_WON,
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_OPENING_HAND) + pl.col(ColName.WON_DRAWN),
-        dependencies=[ColName.WON_OPENING_HAND, ColName.WON_DRAWN],
     ),
     ColumnSpec(
         name=ColName.GIH_WR,
         col_type=ColType.AGG,
         expr=pl.col(ColName.NUM_GIH_WON) / pl.col(ColName.NUM_GIH),
-        dependencies=[ColName.NUM_GIH_WON, ColName.NUM_GIH],
     ),
     ColumnSpec(
         name=ColName.GNS_WR,
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_NUM_GNS) / pl.col(ColName.NUM_GNS),
-        dependencies=[ColName.WON_NUM_GNS, ColName.NUM_GNS],
     ),
     ColumnSpec(
         name=ColName.IWD,
         col_type=ColType.AGG,
         expr=pl.col(ColName.GIH_WR) - pl.col(ColName.GNS_WR),
-        dependencies=[ColName.GIH_WR, ColName.GNS_WR],
     ),
     ColumnSpec(
         name=ColName.NUM_IN_POOL,
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK) + pl.col(ColName.SIDEBOARD),
-        dependencies=[ColName.DECK, ColName.SIDEBOARD],
     ),
     ColumnSpec(
         name=ColName.IN_POOL_WR,
         col_type=ColType.AGG,
         expr=(pl.col(ColName.WON_DECK) + pl.col(ColName.WON_SIDEBOARD))
         / pl.col(ColName.NUM_IN_POOL),
-        dependencies=[ColName.WON_DECK, ColName.WON_SIDEBOARD, ColName.NUM_IN_POOL],
     ),
     ColumnSpec(
         name=ColName.DECK_TOTAL,
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK).sum(),
-        dependencies=[ColName.DECK],
     ),
     ColumnSpec(
         name=ColName.WON_DECK_TOTAL,
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_DECK).sum(),
-        dependencies=[ColName.WON_DECK],
     ),
     ColumnSpec(
         name=ColName.GP_WR_MEAN,
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_DECK_TOTAL) / pl.col(ColName.DECK_TOTAL),
-        dependencies=[ColName.WON_DECK_TOTAL, ColName.DECK_TOTAL],
     ),
     ColumnSpec(
         name=ColName.GP_WR_EXCESS,
         col_type=ColType.AGG,
         expr=pl.col(ColName.GP_WR) - pl.col(ColName.GP_WR_MEAN),
-        dependencies=[ColName.GP_WR, ColName.GP_WR_MEAN],
     ),
     ColumnSpec(
         name=ColName.GP_WR_VAR,
         col_type=ColType.AGG,
         expr=(pl.col(ColName.GP_WR_EXCESS).pow(2) * pl.col(ColName.NUM_GP)).sum()
         / pl.col(ColName.DECK_TOTAL),
-        dependencies=[ColName.GP_WR_EXCESS, ColName.NUM_GP, ColName.DECK_TOTAL],
     ),
     ColumnSpec(
         name=ColName.GP_WR_STDEV,
         col_type=ColType.AGG,
         expr=pl.col(ColName.GP_WR_VAR).sqrt(),
-        dependencies=[ColName.GP_WR_VAR],
     ),
     ColumnSpec(
         name=ColName.GP_WR_Z,
         col_type=ColType.AGG,
         expr=pl.col(ColName.GP_WR_EXCESS) / pl.col(ColName.GP_WR_STDEV),
-        dependencies=[ColName.GP_WR_EXCESS, ColName.GP_WR_STDEV],
     ),
     ColumnSpec(
         name=ColName.GIH_TOTAL,
         col_type=ColType.AGG,
         expr=pl.col(ColName.NUM_GIH).sum(),
-        dependencies=[ColName.NUM_GIH],
     ),
     ColumnSpec(
         name=ColName.WON_GIH_TOTAL,
         col_type=ColType.AGG,
         expr=pl.col(ColName.NUM_GIH_WON).sum(),
-        dependencies=[ColName.NUM_GIH_WON],
     ),
     ColumnSpec(
         name=ColName.GIH_WR_MEAN,
         col_type=ColType.AGG,
         expr=pl.col(ColName.WON_GIH_TOTAL) / pl.col(ColName.GIH_TOTAL),
-        dependencies=[ColName.WON_GIH_TOTAL, ColName.GIH_TOTAL],
     ),
     ColumnSpec(
         name=ColName.GIH_WR_EXCESS,
         col_type=ColType.AGG,
         expr=pl.col(ColName.GIH_WR) - pl.col(ColName.GIH_WR_MEAN),
-        dependencies=[ColName.GIH_WR, ColName.GIH_WR_MEAN],
     ),
     ColumnSpec(
         name=ColName.GIH_WR_VAR,
         col_type=ColType.AGG,
         expr=(pl.col(ColName.GIH_WR_EXCESS).pow(2) * pl.col(ColName.NUM_GIH)).sum()
         / pl.col(ColName.GIH_TOTAL),
-        dependencies=[ColName.GIH_WR_EXCESS, ColName.NUM_GIH, ColName.GIH_TOTAL],
     ),
     ColumnSpec(
         name=ColName.GIH_WR_STDEV,
         col_type=ColType.AGG,
         expr=pl.col(ColName.GIH_WR_VAR).sqrt(),
-        dependencies=[ColName.GIH_WR_VAR],
     ),
     ColumnSpec(
         name=ColName.GIH_WR_Z,
         col_type=ColType.AGG,
         expr=pl.col(ColName.GIH_WR_EXCESS) / pl.col(ColName.GIH_WR_STDEV),
-        dependencies=[ColName.GIH_WR_EXCESS, ColName.GIH_WR_STDEV],
     ),
     ColumnSpec(
         name=ColName.DECK_MANA_VALUE_AVG,
         col_type=ColType.AGG,
-        expr=pl.col(ColName.DECK_MANA_VALUE) / pl.col(ColName.DECK),
-        dependencies=[ColName.DECK_MANA_VALUE, ColName.DECK],
+        expr=pl.col(ColName.DECK_MANA_VALUE) / pl.col(ColName.DECK_SPELLS),
+    ),
+    ColumnSpec(
+        name=ColName.DECK_LANDS_AVG,
+        col_type=ColType.AGG,
+        expr=pl.col(ColName.DECK_LANDS) / pl.col(ColName.NUM_GAMES),
+    ),
+    ColumnSpec(
+        name=ColName.DECK_SPELLS_AVG,
+        col_type=ColType.AGG,
+        expr=pl.col(ColName.DECK_SPELLS) / pl.col(ColName.NUM_GAMES),
     ),
 ]
 

spells/draft_data.py

@@ -10,7 +10,8 @@ import datetime
 import functools
 import hashlib
 import re
-from typing import Callable, TypeVar
+from inspect import signature
+from typing import Callable, TypeVar, Any
 
 import polars as pl
 
@@ -33,7 +34,7 @@ def _cache_key(args) -> str:
 
 
 @functools.lru_cache(maxsize=None)
-def _get_names(set_code: str) -> tuple[str, ...]:
+def _get_names(set_code: str) -> list[str]:
     card_fp = data_file_path(set_code, View.CARD)
     card_view = pl.read_parquet(card_fp)
     card_names_set = frozenset(card_view.get_column("name").to_list())
@@ -43,7 +44,7 @@ def _get_names(set_code: str) -> tuple[str, ...]:
     cols = draft_view.collect_schema().names()
 
     prefix = "pack_card_"
-    names = tuple(col[len(prefix) :] for col in cols if col.startswith(prefix))
+    names = [col[len(prefix) :] for col in cols if col.startswith(prefix)]
     draft_names_set = frozenset(names)
 
     assert (
@@ -52,34 +53,39 @@ def _get_names(set_code: str) -> tuple[str, ...]:
     return names
 
 
-def _hydrate_col_defs(set_code: str, col_spec_map: dict[str, ColumnSpec]):
-    def get_views(spec: ColumnSpec) -> set[View]:
-        if spec.name == ColName.NAME or spec.col_type in (
-            ColType.AGG,
-            ColType.CARD_SUM,
-        ):
-            return set()
-        if spec.col_type == ColType.CARD_ATTR:
-            return {View.CARD}
-        if spec.views is not None:
-            return set(spec.views)
-        assert (
-            spec.dependencies is not None
-        ), f"Col {spec.name} should have dependencies"
-
-        views = functools.reduce(
-            lambda prev, curr: prev.intersection(curr),
-            [get_views(col_spec_map[dep]) for dep in spec.dependencies],
-        )
+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}
+    col_def_map = _hydrate_col_defs(set_code, card_attr_specs, card_only=True)
 
-        return views
+    columns = list(col_def_map.keys())
+
+    fp = data_file_path(set_code, View.CARD)
+    card_df = pl.read_parquet(fp)
+    select_rows = _view_select(
+        card_df, frozenset(columns), col_def_map, is_agg_view=False
+    ).to_dicts()
+
+    card_context = {row[ColName.NAME]: row for row in select_rows}
+
+    return card_context
+    
+
+def _determine_expression(spec: ColumnSpec, names: list[str], card_context: dict[str, dict]) -> pl.Expr | tuple[pl.Expr, ...]:
+    def seed_params(expr):
+        params = {}
+
+        sig_params = signature(expr).parameters
+        if 'names' in sig_params:
+            params['names'] = names
+        if 'card_context' in sig_params:
+            params['card_context'] = card_context
+        return params
+
+    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"
+            unnamed_exprs = [spec.expr(**{'name': name, **seed_params(spec.expr)}) for name in names]
 
-    names = _get_names(set_code)
-    assert len(names) > 0, "there should be names"
-    hydrated = {}
-    for key, spec in col_spec_map.items():
-        if spec.col_type == ColType.NAME_SUM and spec.exprMap is not None:
-            unnamed_exprs = map(spec.exprMap, names)
             expr = tuple(
                 map(
                     lambda ex, name: ex.alias(f"{spec.name}_{name}"),
@@ -87,14 +93,76 @@ def _hydrate_col_defs(set_code: str, col_spec_map: dict[str, ColumnSpec]):
                     names,
                 )
             )
-        elif spec.expr is not None:
-            expr = spec.expr.alias(spec.name)
-
         else:
-            if spec.col_type == ColType.NAME_SUM:
-                expr = tuple(map(lambda name: pl.col(f"{spec.name}_{name}"), names))
+            expr = tuple(map(lambda name: pl.col(f"{spec.name}_{name}"), names))
+
+    elif spec.expr is not None:
+        if isinstance(spec.expr, Callable):
+            params = seed_params(spec.expr)
+            if spec.col_type == ColType.PICK_SUM and 'name' in signature(spec.expr).parameters:
+                expr = pl.lit(None)
+                for name in names:
+                    name_params = {'name': name, **params}
+                    expr = pl.when(pl.col(ColName.PICK) == name).then(spec.expr(**name_params)).otherwise(expr)
             else:
-                expr = pl.col(spec.name)
+                expr = spec.expr(**params)
+        else:
+            expr = spec.expr
+        expr = expr.alias(spec.name)
+    else:
+        expr = pl.col(spec.name)
+
+    return expr
+
+
+def _infer_dependencies(name: str, expr: pl.Expr | tuple[pl.Expr,...], col_spec_map: dict[str, ColumnSpec], 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():
+                dependencies.add(dep_col)
+            else: 
+                tricky_ones.add(dep_col)
+    else:
+        for idx, exp in enumerate(expr):
+            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():
+                    dependencies.add(dep_col)
+                elif len(split := re.split(pattern, dep_col)) == 2 and split[0] in col_spec_map:
+                    dependencies.add(split[0])
+                else:
+                    tricky_ones.add(dep_col)
+
+    for item in tricky_ones:
+        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:
+                dependencies.add(split[0])
+                found = True
+        assert found, f"Could not locate column spec for root col {item}" 
+
+    return dependencies
+
+
+def _hydrate_col_defs(set_code: str, col_spec_map: dict[str, ColumnSpec], card_only=False):
+    names = _get_names(set_code)
+
+    if card_only:
+        card_context = {}
+    else:
+        card_context = _get_card_context(set_code, col_spec_map)
+
+    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)
 
         try:
             sig_expr = expr if isinstance(expr, pl.Expr) else expr[0]
@@ -107,14 +175,11 @@ def _hydrate_col_defs(set_code: str, col_spec_map: dict[str, ColumnSpec]):
             else:
                 expr_sig = str(datetime.datetime.now)
 
-        dependencies = tuple(spec.dependencies or ())
-        views = get_views(spec)
         signature = str(
             (
                 spec.name,
                 spec.col_type.value,
                 expr_sig,
-                tuple(view.value for view in views),
                 dependencies,
             )
         )
@@ -122,7 +187,7 @@ def _hydrate_col_defs(set_code: str, col_spec_map: dict[str, ColumnSpec]):
         cdef = ColumnDefinition(
             name=spec.name,
             col_type=spec.col_type,
-            views=views,
+            views=set(spec.views or set()),
             expr=expr,
             dependencies=dependencies,
             signature=signature,
@@ -136,18 +201,13 @@ def _view_select(
     view_cols: frozenset[str],
     col_def_map: dict[str, ColumnDefinition],
     is_agg_view: bool,
-    is_card_sum: bool = False,
 ) -> DF:
     base_cols = frozenset()
     cdefs = [col_def_map[c] for c in view_cols]
     select = []
     for cdef in cdefs:
         if is_agg_view:
-            if (
-                cdef.col_type == ColType.AGG
-                or cdef.col_type == ColType.CARD_SUM
-                and is_card_sum
-            ):
+            if cdef.col_type == ColType.AGG:
                 base_cols = base_cols.union(cdef.dependencies)
                 select.append(cdef.expr)
             else:
@@ -164,7 +224,7 @@ def _view_select(
                 select.append(cdef.expr)
 
     if base_cols != view_cols:
-        df = _view_select(df, base_cols, col_def_map, is_agg_view, is_card_sum)
+        df = _view_select(df, base_cols, col_def_map, is_agg_view)
 
     return df.select(select)
 
@@ -274,28 +334,6 @@ def _base_agg_df(
     )
 
 
-def card_df(
-    set_code: str,
-    extensions: list[ColumnSpec] | None = None,
-):
-    col_spec_map = dict(spells.columns.col_spec_map)
-    if extensions is not None:
-        for spec in extensions:
-            col_spec_map[spec.name] = spec
-
-    col_def_map = _hydrate_col_defs(set_code, col_spec_map)
-
-    columns = [ColName.NAME] + [
-        c for c, cdef in col_def_map.items() if cdef.col_type == ColType.CARD_ATTR
-    ]
-    fp = data_file_path(set_code, View.CARD)
-    card_df = pl.read_parquet(fp)
-    select_df = _view_select(
-        card_df, frozenset(columns), col_def_map, is_agg_view=False
-    )
-    return select_df.select(columns)
-
-
 def summon(
     set_code: str,
     columns: list[str] | None = None,
@@ -337,12 +375,6 @@ def summon(
         select_df = _view_select(card_df, card_cols, m.col_def_map, is_agg_view=False)
         agg_df = agg_df.join(select_df, on="name", how="outer", coalesce=True)
 
-        if m.card_sum:
-            card_sum_df = _view_select(
-                agg_df, m.card_sum, m.col_def_map, is_agg_view=True, is_card_sum=True
-            )
-            agg_df = pl.concat([agg_df, card_sum_df], how="horizontal")
-
         if ColName.NAME not in m.group_by:
             agg_df = agg_df.group_by(m.group_by).sum()
 

spells/enums.py

@@ -19,7 +19,6 @@ class ColType(StrEnum):
     NAME_SUM = "name_sum"
     AGG = "agg"
     CARD_ATTR = "card_attr"
-    CARD_SUM = "card_sum"
 
 
 class ColName(StrEnum):
@@ -117,6 +116,8 @@ class ColName(StrEnum):
     SUBTYPE = "subtype"
     MANA_VALUE = "mana_value"
     DECK_MANA_VALUE = "deck_mana_value"
+    DECK_LANDS = "deck_lands"
+    DECK_SPELLS = "deck_spells"
     MANA_COST = "mana_cost"
     POWER = "power"
     TOUGHNESS = "toughness"
@@ -157,3 +158,5 @@ class ColName(StrEnum):
     GIH_WR_STDEV = "gh_wr_stdev"
     GIH_WR_Z = "gih_wr_z"
     DECK_MANA_VALUE_AVG = "deck_mana_value_avg"
+    DECK_LANDS_AVG = "deck_lands_avg"
+    DECK_SPELLS_AVG = "deck_spells_avg"

spells/manifest.py

@@ -14,7 +14,6 @@ class Manifest:
     view_cols: dict[View, frozenset[str]]
     group_by: tuple[str, ...]
     filter: spells.filter.Filter | None
-    card_sum: frozenset[str]
 
     def __post_init__(self):
         # No name filter check
@@ -40,21 +39,13 @@ class Manifest:
             ), f"Invalid groupby {col}!"
 
         for view, cols_for_view in self.view_cols.items():
-            # cols_for_view are actually in view check
             for col in cols_for_view:
-                assert (
-                    view in self.col_def_map[col].views
-                ), f"View cols generated incorrectly, {col} not in view {view}"
                 # game sum cols on in game, and no NAME groupby
                 assert self.col_def_map[col].col_type != ColType.GAME_SUM or (
                     view == View.GAME and ColName.NAME not in self.base_view_group_by
                 ), f"Invalid manifest for GAME_SUM column {col}"
             if view != View.CARD:
                 for col in self.base_view_group_by:
-                    # base_view_groupbys in view check
-                    assert (
-                        col == ColName.NAME or view in self.col_def_map[col].views
-                    ), f"Groupby {col} not in view {view}!"
                     # base_view_groupbys in view_cols for view
                     assert (
                         col == ColName.NAME or col in cols_for_view
@@ -95,7 +86,7 @@ class Manifest:
 def _resolve_view_cols(
     col_set: frozenset[str],
     col_def_map: dict[str, ColumnDefinition],
-) -> tuple[dict[View, frozenset[str]], frozenset[str]]:
+) -> dict[View, frozenset[str]]:
     """
     For each view ('game', 'draft', and 'card'), return the columns
     that must be present at the aggregation step. 'name' need not be
@@ -104,7 +95,6 @@ def _resolve_view_cols(
     MAX_DEPTH = 1000
     unresolved_cols = col_set
     view_resolution = {}
-    card_sum = frozenset()
 
     iter_num = 0
     while unresolved_cols and iter_num < MAX_DEPTH:
@@ -116,9 +106,9 @@ def _resolve_view_cols(
                 view_resolution[View.DRAFT] = view_resolution.get(
                     View.DRAFT, frozenset()
                 ).union({ColName.PICK})
-            if cdef.col_type == ColType.CARD_SUM:
-                card_sum = card_sum.union({col})
-            if cdef.views:
+            if cdef.col_type == ColType.CARD_ATTR:
+                view_resolution[View.CARD] = view_resolution.get(View.CARD, frozenset()).union({col})
+            elif cdef.views:
                 for view in cdef.views:
                     view_resolution[view] = view_resolution.get(
                         view, frozenset()
@@ -128,14 +118,38 @@ def _resolve_view_cols(
                     raise ValueError(
                         f"Invalid column def: {col} has neither views nor dependencies!"
                     )
-                for dep in cdef.dependencies:
-                    next_cols = next_cols.union({dep})
+                if cdef.col_type != ColType.AGG:
+                    fully_resolved = True
+                    col_views = frozenset({View.GAME, View.DRAFT, View.CARD})
+                    for dep in cdef.dependencies:
+                        dep_views = frozenset()
+                        for view, view_cols in view_resolution.items():
+                            if dep in view_cols:
+                                dep_views = dep_views.union({view})
+                        if not dep_views:
+                            fully_resolved = False
+                            next_cols = next_cols.union({dep})
+                        else:
+                            col_views = col_views.intersection(dep_views)
+                    if fully_resolved:
+                        assert len(col_views), f"Column {col} can't be defined in any views!"
+                        for view in col_views:
+                            if view not in view_resolution:
+                                print(cdef)
+                                assert False, f"Something went wrong with col {col}"
+
+                            view_resolution[view] = view_resolution[view].union({col})
+                    else:
+                        next_cols = next_cols.union({col})
+                else:
+                    for dep in cdef.dependencies:
+                        next_cols = next_cols.union({dep})
         unresolved_cols = next_cols
 
     if iter_num >= MAX_DEPTH:
         raise ValueError("broken dependency chain in column spec, loop probable")
 
-    return view_resolution, card_sum
+    return view_resolution
 
 
 def create(
@@ -148,7 +162,7 @@ def create(
     if columns is None:
         cols = tuple(spells.columns.default_columns)
         if ColName.NAME not in gbs:
-            cols = tuple(c for c in cols if c not in [ColName.COLOR, ColName.RARITY])
+            cols = tuple(c for c in cols if col_def_map[c].col_type != ColType.CARD_ATTR)
     else:
         cols = tuple(columns)
 
@@ -159,12 +173,8 @@ def create(
     if m_filter is not None:
         col_set = col_set.union(m_filter.lhs)
 
-    view_cols, card_sum = _resolve_view_cols(col_set, col_def_map)
     base_view_group_by = frozenset()
 
-    if card_sum:
-        base_view_group_by = base_view_group_by.union({ColName.NAME})
-
     for col in gbs:
         cdef = col_def_map[col]
         if cdef.col_type == ColType.GROUP_BY:
@@ -172,14 +182,23 @@ def create(
         elif cdef.col_type == ColType.CARD_ATTR:
             base_view_group_by = base_view_group_by.union({ColName.NAME})
 
+    view_cols = _resolve_view_cols(col_set, col_def_map)
+
     needed_views = frozenset()
-    for view, cols_for_view in view_cols.items():
-        for col in cols_for_view:
-            if col_def_map[col].views == {view}:  # only found in this view
-                needed_views = needed_views.union({view})
+    if View.CARD in view_cols:
+        needed_views = needed_views.union({View.CARD})
 
-    if not needed_views:
-        needed_views = {View.DRAFT}
+    draft_view_cols = view_cols.get(View.DRAFT, frozenset())
+    game_view_cols = view_cols.get(View.GAME, frozenset())
+
+    base_cols = draft_view_cols.union(game_view_cols)
+
+    if base_cols == draft_view_cols:
+        needed_views = needed_views.union({View.DRAFT})
+    elif base_cols == game_view_cols:
+        needed_views = needed_views.union({View.GAME})
+    else:
+        needed_views = needed_views.union({View.GAME, View.DRAFT})
 
     view_cols = {v: view_cols[v] for v in needed_views}
 
@@ -190,5 +209,4 @@ def create(
         view_cols=view_cols,
         group_by=gbs,
         filter=m_filter,
-        card_sum=card_sum,
     )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spells-mtg
-Version: 0.3.0
+Version: 0.4.0
 Summary: analaysis of 17Lands.com public datasets
 Author-Email: Joel Barnes <oelarnes@gmail.com>
 License: MIT
@@ -74,7 +74,7 @@ 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 118 explicitly specified, enumerated, documented column definitions
+- Provides 121 explicitly specified, enumerated, documented column definitions
 - Supports "Deck Color Data" aggregations with built-in column definitions.
 - Provides a CLI tool `spells [add|refresh|clean|remove|info] [SET]` to download and manage external files
 - Downloads and manages public datasets from 17Lands
@@ -112,24 +112,24 @@ Spells is not affiliated with 17Lands. Please review the [Usage Guidelines](http
     ```
   - `group_by` specifies the grouping by one or more columns. By default, group by card names, but optionally group by any of a large set of fundamental and derived columns, including card attributes and your own custom extension.
     ```python
-    >>> spells.summon('BLB', columns=["num_won", "num_games", "game_wr"], group_by=["main_colors"], filter_spec={"num_colors": 2})
-    shape: (10, 4)
-    ┌─────────────┬─────────┬───────────┬──────────┐
-    │ main_colors ┆ num_won ┆ num_games ┆ game_wr  │
-    │ ---         ┆ ---     ┆ ---       ┆ ---      │
-    │ str         ┆ u32     ┆ u32       ┆ f64      │
-    ╞═════════════╪═════════╪═══════════╪══════════╡
-    │ BG          ┆ 85022   ┆ 152863    ┆ 0.556197 │
-    │ BR          ┆ 45900   ┆ 81966     ┆ 0.559988 │
-    │ RG          ┆ 34641   ┆ 64428     ┆ 0.53767  │
-    │ UB          ┆ 30922   ┆ 57698     ┆ 0.535928 │
-    │ UG          ┆ 59879   ┆ 109145    ┆ 0.548619 │
-    │ UR          ┆ 19638   ┆ 38679     ┆ 0.507717 │
-    │ WB          ┆ 59480   ┆ 107443    ┆ 0.553596 │
-    │ WG          ┆ 76134   ┆ 136832    ┆ 0.556405 │
-    │ WR          ┆ 49712   ┆ 91224     ┆ 0.544944 │
-    │ WU          ┆ 16483   ┆ 31450     ┆ 0.524102 │
-    └─────────────┴─────────┴───────────┴──────────┘
+    >>> summon('BLB', columns=["num_won", "num_games", "game_wr", "deck_mana_value_avg"], group_by=["main_colors"], filter_spec={"num_colors": 2})
+    shape: (10, 5)
+    ┌─────────────┬─────────┬───────────┬──────────┬─────────────────────┐
+    │ main_colors ┆ num_won ┆ num_games ┆ game_wr  ┆ deck_mana_value_avg │
+    │ ---         ┆ ---     ┆ ---       ┆ ---      ┆ ---                 │
+    │ str         ┆ u32     ┆ u32       ┆ f64      ┆ f64                 │
+    ╞═════════════╪═════════╪═══════════╪══════════╪═════════════════════╡
+    │ BG          ┆ 85022   ┆ 152863    ┆ 0.556197 ┆ 2.862305            │
+    │ BR          ┆ 45900   ┆ 81966     ┆ 0.559988 ┆ 2.76198             │
+    │ RG          ┆ 34641   ┆ 64428     ┆ 0.53767  ┆ 2.852182            │
+    │ UB          ┆ 30922   ┆ 57698     ┆ 0.535928 ┆ 3.10409             │
+    │ UG          ┆ 59879   ┆ 109145    ┆ 0.548619 ┆ 2.861026            │
+    │ UR          ┆ 19638   ┆ 38679     ┆ 0.507717 ┆ 2.908215            │
+    │ WB          ┆ 59480   ┆ 107443    ┆ 0.553596 ┆ 2.9217              │
+    │ WG          ┆ 76134   ┆ 136832    ┆ 0.556405 ┆ 2.721064            │
+    │ WR          ┆ 49712   ┆ 91224     ┆ 0.544944 ┆ 2.5222              │
+    │ WU          ┆ 16483   ┆ 31450     ┆ 0.524102 ┆ 2.930967            │
+    └─────────────┴─────────┴───────────┴──────────┴─────────────────────┘ 
     ```
   - `filter_spec` specifies a row-level filter for the dataset, using an intuitive custom query formulation
     ```python
@@ -156,8 +156,7 @@ Spells is not affiliated with 17Lands. Please review the [Usage Guidelines](http
     ...     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'),
-    ...     dependencies=['gp_wr_excess', 'ata', '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'])
@@ -278,13 +277,13 @@ summon(
 
 #### parameters
 
-- columns: a list of string or `ColName` values to select as non-grouped columns. Valid `ColTypes` are `PICK_SUM`, `NAME_SUM`, `GAME_SUM`, `CARD_ATTR`, `CARD_SUM` and `AGG`. Min/Max/Unique 
+- columns: a list of string or `ColName` values to select as non-grouped columns. Valid `ColTypes` are `PICK_SUM`, `NAME_SUM`, `GAME_SUM`, `CARD_ATTR`, and `AGG`. Min/Max/Unique 
 aggregations of non-numeric (or numeric) data types are not supported. If `None`, use a set of columns modeled on the commonly used values on 17Lands.com/card_data.
 
 - group_by: a list of string or `ColName` values to display as grouped columns. Valid `ColTypes` are `GROUP_BY` and `CARD_ATTR`. By default, group by "name" (card name).
 
 - filter_spec: a dictionary specifying a filter, using a small number of paradigms. Columns used must be in each base view ("draft" and "game") that the `columns` and `group_by` columns depend on, so 
-`AGG`, `CARD_SUM` and `CARD_ATTR` columns are not valid. `NAME_SUM` columns are also not supported. Derived columns are supported. No filter is applied by default. Yes, I should rewrite it to use the mongo query language. The specification is best understood with examples:
+`AGG` and `CARD_ATTR` columns are not valid. Functions of card attributes in the base views can be filtered on, see the documentation for `expr` for details. `NAME_SUM` columns are also not supported. Derived columns are supported. No filter is applied by default. Yes, I should rewrite it to use the mongo query language. The specification is best understood with examples:
 
     - `{'player_cohort': 'Top'}` "player_cohort" value equals "Top".
     - `{'lhs': 'player_cohort', 'op': 'in', 'rhs': ['Top', 'Middle']}` "player_cohort" value is either "Top" or "Middle". Supported values for `op` are `<`, `<=`, `>`, `>=`, `!=`, `=`, `in` and `nin`.
@@ -297,10 +296,10 @@ aggregations of non-numeric (or numeric) data types are not supported. If `None`
 ### Enums
 
 ```python
-from spells.enums import ColName, ColType, View
+from spells.enums import ColName, ColType
 ```
 
-Recommended to import `ColName` for any usage of `summon`, and to import `ColType` when defining custom extensions. You shouldn't need `VIEW`.
+Recommended to import `ColName` for any usage of `summon`, and to import `ColType` when defining custom extensions.
 
 ### ColumnSpec
 
@@ -310,11 +309,8 @@ from spells.columns import ColumnSpec
 ColumnSpec(
     name: str,
     col_type: ColType,
-    expr: pl.Expr | None = None,
-    exprMap: Callable[[str], pl.Expr] | None = None
-    dependencies: list[str] | None = None
+    expr: pl.Expr | Callable[..., pl.Expr] | None = None,
     version: str | None = None
-    views: list[View] | None = None,
 )
 ```
 
@@ -324,19 +320,19 @@ Used to define extensions in `summon`
 
 - `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`, `CARD_SUM`, and `AGG`. See documentation for `summon` for usage. All columns except `CARD_ATTR`, `CARD_SUM` 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. `CARD_SUM` columns are expressed similarly to `AGG`, but they are calculated before grouping by card name and are summed before the `AGG` selection stage (for example, to calculate average mana value. See example notebook "Card Attributes"). Arbitrarily long chains of aggregate dependencies are supported.
-
-- `expr`: A polars expression giving the derivation of the column value at the first level where it is defined. For `NAME_SUM` columns the `exprMap` attribute must be used instead. `AGG` columns that depend on `NAME_SUM` columns reference the prefix (`cdef.name`) only, since the unpivot has occured prior to selection.
+- `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.
 
-- `exprMap`: A function of card name that returns the expression for a `NAME_SUM` column. 
-
-- `dependencies`: A list of column names. All dependencies must be declared by name.
+- `expr`: A polars expression or function returning a polars expression giving the derivation of the column value at the first level where it is defined. 
+    - 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.
 
 - `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.
 
-- `views`: Not needed for custom columns.
-
 ### Columns
 
 A table of all included columns. Columns can be referenced by enum or by string value in arguments and filter specs. The string value is always the lowercase version of the enum attribute.
@@ -424,6 +420,9 @@ A table of all included columns. Columns can be referenced by enum or by string
 | `CARD_TYPE` | `"card_type"` | `CARD` | `CARD_ATTR` | | String |
 | `SUBTYPE` | `"subtype"` | `CARD` | `CARD_ATTR` | | String |
 | `MANA_VALUE` | `"mana_value"` | `CARD` | `CARD_ATTR` | | Float |
+| `DECK_MANA_VALUE` | `"deck_mana_value"` | | `NAME_SUM` | `DECK` * `MANA_VALUE` | Float |
+| `DECK_LANDS` | `"deck_lands"` | | `NAME_SUM` | Number of lands in deck | Float |
+| `DECK_SPELLS` | `"deck_spells"` | | `NAME_SUM` | Number of spells in deck | Float |
 | `MANA_COST` | `"mana_cost"` | `CARD` | `CARD_ATTR` | | String |
 | `POWER` | `"power"` | `CARD` | `CARD_ATTR` | | Float |
 | `TOUGHNESS` | `"toughness"` | `CARD` | `CARD_ATTR` | | Float |
@@ -462,6 +461,9 @@ A table of all included columns. Columns can be referenced by enum or by string
 | `GIH_WR_VAR` | `"gih_wr_var"` | | `AGG` | Game-weighted Variance | Float |
 | `GIH_WR_STDEV` | `"gh_wr_stdev"` | | `AGG` | Sqrt of `GIH_WR_VAR` | Float |
 | `GIH_WR_Z` | `"gih_wr_z"` | | `AGG` |`GIH_WR_EXCESS` / `GIH_WR_STDEV` | Float |
+| `DECK_MANA_VALUE_AVG` | `"deck_mana_value_avg"` | | `AGG` | `DECK_MANA_VALUE ` / `DECK_SPELLS` | Float |
+| `DECK_LANDS_AVG` | `"deck_lands_avg"` | | `AGG` | `DECK_LANDS ` / `NUM_GAMES` | Float |
+| `DECK_SPELLS_AVG` | `"deck_spells_avg"` | | `AGG` | `DECK_SPELLS ` / `NUM_GAMES` | Float |
 
 # Roadmap to 1.0
 

spells_mtg-0.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+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,,

spells_mtg-0.3.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-spells/__init__.py,sha256=QCPWQySUK2SZtCU-mSZLsn7vrNLJMDsRwil8gmAzmdk,151
-spells/cache.py,sha256=4v7h8D3TtaT0R_EdiRNhdcQrXzdH_CukezO6oAXvNEY,2956
-spells/cards.py,sha256=6seKpgI4TlJxI20bvcgt5VpxzsbCnnjWneDWpneJJ6Y,3497
-spells/columns.py,sha256=_x7vVSh-55TJRjV7LQ29Kj_Ek__ef4pvxUsX57s9Iwo,22488
-spells/draft_data.py,sha256=ABIQoUD8MKnc2goTUGY33dOxCpH8ydXXuQnbHMNULZs,10999
-spells/enums.py,sha256=t-1PrBUqbxZRShDOgmTHkhiHIOIMHTbD7RUgKiQdx-c,4621
-spells/external.py,sha256=qe6wOBDhPN4CZNQvYRq6G-OpIZcWTZzJjySgnf2Gu1o,10258
-spells/filter.py,sha256=J-YTOOAzOQpvIX29tviYL04RVoOUlfsbjBXoQBDCEdQ,3380
-spells/manifest.py,sha256=oGkWuBYquJYmtaIp2O-x5nFKD5TkU5lzS-vera69jyU,7244
-spells/schema.py,sha256=z8Qn2SiHG4T6YfPsz8xHLGMjU_Ofm76-Vrquh3b9B64,6422
-spells_mtg-0.3.0.dist-info/METADATA,sha256=hhHnMORK-fcalrC-Y416Eyfx-ZBaldqZYaXKpMSh7a8,42882
-spells_mtg-0.3.0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-spells_mtg-0.3.0.dist-info/entry_points.txt,sha256=a9Y1omdl9MdnKuIj3aOodgrp-zZII6OCdvqwgP6BFvI,63
-spells_mtg-0.3.0.dist-info/licenses/LICENSE,sha256=tS54XYbJSgmq5zuHhbsQGbNQLJPVgXqhF5nu2CSRMig,1068
-spells_mtg-0.3.0.dist-info/RECORD,,