spells-mtg 0.10.11__tar.gz → 0.11.1__tar.gz

{spells_mtg-0.10.11 → spells_mtg-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spells-mtg
-Version: 0.10.11
+Version: 0.11.1
 Summary: analaysis of 17Lands.com public datasets
 Author-Email: Joel Barnes <oelarnes@gmail.com>
 License: MIT

{spells_mtg-0.10.11 → spells_mtg-0.11.1}/pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "0.10.11"
+version = "0.11.1"
 
 [project.license]
 text = "MIT"

spells_mtg-0.11.1/spells/.ruff_cache/.gitignore

@@ -0,0 +1,2 @@
+# Automatically created by ruff.
+*

spells_mtg-0.11.1/spells/.ruff_cache/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

{spells_mtg-0.10.11 → spells_mtg-0.11.1}/spells/cache.py

@@ -7,6 +7,7 @@ and groupbys.
 Caches are cleared per-set when new files are downloaded.
 """
 
+import datetime as dt
 from enum import StrEnum
 import os
 from pathlib import Path
@@ -31,6 +32,8 @@ class EventType(StrEnum):
 class DataDir(StrEnum):
     CACHE = "cache"
     EXTERNAL = "external"
+    RATINGS = "ratings"
+    DECK_COLOR = "deck_color"
 
 
 def spells_print(mode, content):
@@ -141,6 +144,8 @@ def data_dir_path(cache_dir: DataDir) -> str:
     ext = {
         DataDir.CACHE: "Cache" if is_win else "cache",
         DataDir.EXTERNAL: "External" if is_win else "external",
+        DataDir.RATINGS: "Ratings" if is_win else "ratings",
+        DataDir.DECK_COLOR: "DeckColor" if is_win else "deck_color",
     }[cache_dir]
 
     data_dir = os.path.join(data_home(), ext)
@@ -163,6 +168,38 @@ def data_file_path(set_code, dataset_type: str, event_type=EventType.PREMIER):
     )
 
 
+def card_ratings_file_path(
+    set_code: str,
+    format: str,
+    user_group: str,
+    deck_color: str,
+    start_date: dt.date,
+    end_date: dt.date,
+) -> tuple[str, str]:
+    return os.path.join(
+        data_dir_path(DataDir.RATINGS),
+        set_code,
+    ), (
+        f"{format}_{user_group}_{deck_color}_{start_date.strftime('%Y-%m-%d')}"
+        f"_{end_date.strftime('%Y-%m-%d')}.json"
+    )
+
+def deck_color_file_path(
+    set_code: str,
+    format: str,
+    user_group: str,
+    start_date: dt.date,
+    end_date: dt.date,
+) -> tuple[str, str]:
+    return os.path.join(
+        data_dir_path(DataDir.DECK_COLOR),
+        set_code,
+    ), (
+        f"{format}_{user_group}_{start_date.strftime('%Y-%m-%d')}"
+        f"_{end_date.strftime('%Y-%m-%d')}.json"
+    )
+
+
 def cache_dir_for_set(set_code: str) -> str:
     return os.path.join(data_dir_path(DataDir.CACHE), set_code)
 

spells_mtg-0.11.1/spells/card_data_files.py

@@ -0,0 +1,192 @@
+import datetime as dt
+import os
+import wget
+from time import sleep
+
+import polars as pl
+
+from spells import cache
+from spells.enums import ColName
+
+RATINGS_TEMPLATE = (
+    "https://www.17lands.com/card_ratings/data?expansion={set_code}&format={format}"
+    "{user_group_param}{deck_color_param}&start_date={start_date_str}&end_date={end_date_str}"
+)
+
+DECK_COLOR_DATA_TEMPLATE = (
+    "https://www.17lands.com/color_ratings/data?expansion={set_code}&event_type={format}"
+    "{user_group_param}&start_date={start_date_str}&end_date={end_date_str}&combine_splash=true"
+)
+
+START_DATE_MAP = {
+    "DFT": dt.date(2025, 2, 11),
+    "TDM": dt.date(2025, 4, 8),
+    "FIN": dt.date(2025, 6, 10),
+}
+
+ratings_col_defs = {
+    ColName.NAME: pl.col("name"),
+    ColName.COLOR: pl.col("color"),
+    ColName.RARITY: pl.col("rarity"),
+    ColName.CARD_TYPE: pl.col("types"),
+    ColName.IMAGE_URL: pl.col("url"),
+    ColName.NUM_SEEN: pl.col("seen_count"),
+    ColName.LAST_SEEN: pl.col("seen_count") * pl.col("avg_seen"),
+    ColName.NUM_TAKEN: pl.col("pick_count"),
+    ColName.TAKEN_AT: pl.col("pick_count") * pl.col("avg_pick"),
+    ColName.DECK: pl.col("game_count"),
+    ColName.WON_DECK: pl.col("win_rate") * pl.col("game_count"),
+    ColName.SIDEBOARD: pl.col("pool_count") - pl.col("game_count"),
+    ColName.OPENING_HAND: pl.col("opening_hand_game_count"),
+    ColName.WON_OPENING_HAND: pl.col("opening_hand_game_count")
+    * pl.col("opening_hand_win_rate"),
+    ColName.DRAWN: pl.col("drawn_game_count"),
+    ColName.WON_DRAWN: pl.col("drawn_win_rate") * pl.col("drawn_game_count"),
+    ColName.NUM_GIH: pl.col("ever_drawn_game_count"),
+    ColName.NUM_GIH_WON: pl.col("ever_drawn_game_count")
+    * pl.col("ever_drawn_win_rate"),
+    ColName.NUM_GNS: pl.col("never_drawn_game_count"),
+    ColName.WON_NUM_GNS: pl.col("never_drawn_game_count")
+    * pl.col("never_drawn_win_rate"),
+}
+
+deck_color_col_defs = {
+    ColName.MAIN_COLORS: pl.col("short_name"),
+    ColName.NUM_GAMES: pl.col("games"),
+    ColName.NUM_WON: pl.col("wins"),
+}
+
+
+def deck_color_df(
+    set_code: str,
+    format: str = "PremierDraft",
+    player_cohort: str = "all",
+    start_date: dt.date | None = None,
+    end_date: dt.date | None = None,
+):
+    if start_date is None:
+        start_date = START_DATE_MAP[set_code]
+    if end_date is None:
+        end_date = dt.date.today() - dt.timedelta(days=1)
+
+    target_dir, filename = cache.deck_color_file_path(
+        set_code,
+        format,
+        player_cohort,
+        start_date,
+        end_date,
+    )
+
+    if not os.path.isdir(target_dir):
+        os.makedirs(target_dir)
+
+    deck_color_file_path = os.path.join(target_dir, filename)
+
+    if not os.path.isfile(deck_color_file_path):
+        user_group_param = (
+            "" if player_cohort == "all" else f"&user_group={player_cohort}"
+        )
+
+        url = DECK_COLOR_DATA_TEMPLATE.format(
+            set_code=set_code,
+            format=format,
+            user_group_param=user_group_param,
+            start_date_str=start_date.strftime("%Y-%m-%d"),
+            end_date_str=end_date.strftime("%Y-%m-%d"),
+        )
+
+        wget.download(
+            url,
+            out=deck_color_file_path,
+        )
+
+    df = (
+        pl.read_json(deck_color_file_path)
+        .filter(~pl.col("is_summary"))
+        .select(
+            [
+                pl.lit(set_code).alias(ColName.EXPANSION),
+                pl.lit(format).alias(ColName.EVENT_TYPE),
+                (pl.lit("Top") if player_cohort == "top" else pl.lit(None)).alias(
+                    ColName.PLAYER_COHORT
+                ),
+                *[val.alias(key) for key, val in deck_color_col_defs.items()],
+            ]
+        )
+    )
+
+    return df
+
+
+def base_ratings_df(
+    set_code: str,
+    format: str = "PremierDraft",
+    player_cohort: str = "all",
+    deck_colors: str | list[str] = "any",
+    start_date: dt.date | None = None,
+    end_date: dt.date | None = None,
+) -> pl.DataFrame:
+    if start_date is None:
+        start_date = START_DATE_MAP[set_code]
+    if end_date is None:
+        end_date = dt.date.today() - dt.timedelta(days=1)
+
+    if isinstance(deck_colors, str):
+        deck_colors = [deck_colors]
+
+    concat_list = []
+    for i, deck_color in enumerate(deck_colors):
+        ratings_dir, filename = cache.card_ratings_file_path(
+            set_code,
+            format,
+            player_cohort,
+            deck_color,
+            start_date,
+            end_date,
+        )
+
+        if not os.path.isdir(ratings_dir):
+            os.makedirs(ratings_dir)
+
+        ratings_file_path = os.path.join(ratings_dir, filename)
+
+        if not os.path.isfile(ratings_file_path):
+            if i > 0:
+                sleep(5)
+            user_group_param = (
+                "" if player_cohort == "all" else f"&user_group={player_cohort}"
+            )
+            deck_color_param = "" if deck_color == "any" else f"&deck_colors={deck_color}"
+
+            url = RATINGS_TEMPLATE.format(
+                set_code=set_code,
+                format=format,
+                user_group_param=user_group_param,
+                deck_color_param=deck_color_param,
+                start_date_str=start_date.strftime("%Y-%m-%d"),
+                end_date_str=end_date.strftime("%Y-%m-%d"),
+            )
+
+            wget.download(
+                url,
+                out=ratings_file_path,
+            )
+
+        concat_list.append(pl.read_json(ratings_file_path).with_columns(
+            (pl.lit(deck_color) if deck_color != "any" else pl.lit(None)).alias(
+                ColName.MAIN_COLORS
+            )
+        ))
+    df = pl.concat(concat_list)
+
+    return df.select(
+        [
+            pl.lit(set_code).alias(ColName.EXPANSION),
+            pl.lit(format).alias(ColName.EVENT_TYPE),
+            (pl.lit("Top") if player_cohort == "top" else pl.lit(None)).alias(
+                ColName.PLAYER_COHORT
+            ),
+            ColName.MAIN_COLORS,
+            *[val.alias(key) for key, val in ratings_col_defs.items()],
+        ]
+    )

{spells_mtg-0.10.11 → spells_mtg-0.11.1}/spells/draft_data.py

@@ -6,6 +6,8 @@ Aggregate dataframes containing raw counts are cached in the local file system
 for performance.
 """
 
+from dataclasses import dataclass
+import datetime
 import functools
 import hashlib
 import re
@@ -23,9 +25,19 @@ from spells import manifest
 from spells.columns import ColDef, ColSpec, get_specs
 from spells.enums import View, ColName, ColType
 from spells.log import make_verbose
+from spells.card_data_files import base_ratings_df
 
 DF = TypeVar("DF", pl.LazyFrame, pl.DataFrame)
 
+@dataclass
+class CardDataFileSpec():
+    set_code: str
+    format: str = "PremierDraft"
+    player_cohort: str = "all"
+    deck_colors: str = "any"
+    start_date: datetime.date | None = None
+    end_date: datetime.date | None = None
+
 
 def _cache_key(args) -> str:
     """
@@ -476,6 +488,7 @@ def summon(
     write_cache: bool = True,
     card_context: pl.DataFrame | dict[str, Any] | None = None,
     set_context: pl.DataFrame | dict[str, Any] | None = None,
+    cdfs: CardDataFileSpec | None = None,
 ) -> pl.DataFrame:
     specs = get_specs()
 
@@ -518,30 +531,43 @@ def summon(
         col_def_map = _hydrate_col_defs(code, specs, set_card_context, this_set_context)
         m = manifest.create(col_def_map, columns, group_by, filter_spec)
 
-        calc_fn = functools.partial(_base_agg_df, code, m, use_streaming=use_streaming)
-        agg_df = _fetch_or_cache(
-            calc_fn,
-            code,
-            (
+        if cdfs is None:
+            calc_fn = functools.partial(_base_agg_df, code, m, use_streaming=use_streaming)
+            agg_df = _fetch_or_cache(
+                calc_fn,
                 code,
-                sorted(m.view_cols.get(View.DRAFT, set())),
-                sorted(m.view_cols.get(View.GAME, set())),
-                sorted(c.signature or "" for c in m.col_def_map.values()),
-                sorted(m.base_view_group_by),
-                filter_spec,
-            ),
-            read_cache=read_cache,
-            write_cache=write_cache,
-        )
-
-        if View.CARD in m.view_cols:
-            card_cols = m.view_cols[View.CARD].union({ColName.NAME})
-            fp = cache.data_file_path(code, View.CARD)
-            card_df = pl.read_parquet(fp)
-            select_df = _view_select(
-                card_df, card_cols, m.col_def_map, is_agg_view=False
+                (
+                    code,
+                    sorted(m.view_cols.get(View.DRAFT, set())),
+                    sorted(m.view_cols.get(View.GAME, set())),
+                    sorted(c.signature or "" for c in m.col_def_map.values()),
+                    sorted(m.base_view_group_by),
+                    filter_spec,
+                ),
+                read_cache=read_cache,
+                write_cache=write_cache,
             )
-            agg_df = agg_df.join(select_df, on="name", how="outer", coalesce=True)
+            if View.CARD in m.view_cols:
+                card_cols = m.view_cols[View.CARD].union({ColName.NAME})
+                fp = cache.data_file_path(code, View.CARD)
+                card_df = pl.read_parquet(fp)
+                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)
+        else:
+            assert len(codes) == 1, "Only one set supported for loading from card data file"
+            assert codes[0] == cdfs.set_code, "Wrong set file specified"
+            assert cdfs.format == "PremierDraft", "Only PremierDraft supported"
+            agg_df = base_ratings_df(
+                set_code=cdfs.set_code,
+                format=cdfs.format,
+                player_cohort=cdfs.player_cohort,
+                deck_colors=cdfs.deck_colors,
+                start_date=cdfs.start_date,
+                end_date=cdfs.end_date,
+            )
+
         concat_dfs.append(agg_df)
 
     full_agg_df = pl.concat(concat_dfs, how="vertical")

{spells_mtg-0.10.11 → spells_mtg-0.11.1}/spells/external.py

@@ -30,7 +30,6 @@ RESOURCE_TEMPLATE = (
     "https://17lands-public.s3.amazonaws.com/analysis_data/{dataset_type}_data/"
 )
 
-
 class FileFormat(StrEnum):
     CSV = "csv"
     PARQUET = "parquet"
@@ -121,7 +120,8 @@ def _context() -> int:
     for code in all_sets:
         write_card_file(code, force_download=True)
         get_set_context(code, force_download=True)
-    return 0 
+    return 0
+
 
 def _refresh(set_code: str):
     return _add(set_code, force_download=True)
@@ -359,4 +359,5 @@ def get_set_context(set_code: str, force_download=False) -> int:
     context_df.write_parquet(context_fp)
 
     cache.spells_print(mode, f"Wrote file {context_fp}")
+    
     return 0