spells-mtg 0.5.1__tar.gz → 0.5.3__tar.gz

{spells_mtg-0.5.1 → spells_mtg-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spells-mtg
-Version: 0.5.1
+Version: 0.5.3
 Summary: analaysis of 17Lands.com public datasets
 Author-Email: Joel Barnes <oelarnes@gmail.com>
 License: MIT
@@ -294,7 +294,8 @@ summon(
     columns: list[str] | None = None,
     group_by: list[str] | None = None,
     filter_spec: dict | None = None,
-    extensions: list[str] | None = None,
+    extensions: dict[str, ColSpec] | None = None,
+    card_context: pl.DataFrame | dict[str, dict[str, Any] | None = None,
     read_cache: bool = True,
     write_cache: bool = True,
 ) -> polars.DataFrame

{spells_mtg-0.5.1 → spells_mtg-0.5.3}/README.md

@@ -283,7 +283,8 @@ summon(
     columns: list[str] | None = None,
     group_by: list[str] | None = None,
     filter_spec: dict | None = None,
-    extensions: list[str] | None = None,
+    extensions: dict[str, ColSpec] | None = None,
+    card_context: pl.DataFrame | dict[str, dict[str, Any] | None = None,
     read_cache: bool = True,
     write_cache: bool = True,
 ) -> polars.DataFrame

{spells_mtg-0.5.1 → spells_mtg-0.5.3}/pyproject.toml

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

{spells_mtg-0.5.1 → spells_mtg-0.5.3}/spells/columns.py

@@ -5,7 +5,6 @@ import polars as pl
 
 from spells.enums import View, ColName, ColType
 
-
 @dataclass(frozen=True)
 class ColSpec:
     col_type: ColType
@@ -40,7 +39,7 @@ default_columns = [
     ColName.GIH_WR,
 ]
 
-specs: dict[str, ColSpec] = {
+_specs: dict[str, ColSpec] = {
     ColName.NAME: ColSpec(
         col_type=ColType.GROUP_BY,
         views=[View.CARD],
@@ -477,6 +476,10 @@ specs: dict[str, ColSpec] = {
         col_type=ColType.AGG,
         expr=pl.col(ColName.DECK) + pl.col(ColName.SIDEBOARD),
     ),
+    ColName.NUM_IN_POOL_TOTAL: ColSpec(
+        col_type=ColType.AGG,
+        expr=pl.col(ColName.NUM_IN_POOL).sum(),
+    ),
     ColName.IN_POOL_WR: ColSpec(
         col_type=ColType.AGG,
         expr=(pl.col(ColName.WON_DECK) + pl.col(ColName.WON_SIDEBOARD))
@@ -555,4 +558,13 @@ specs: dict[str, ColSpec] = {
 }
 
 for item in ColName:
-    assert item in specs, f"column {item} enumerated but not specified"
+    assert item in _specs, f"column {item} enumerated but not specified"
+
+class GetSpecs:
+    def __init__(self, spec_dict: dict[str, ColSpec]):
+        self._specs = spec_dict
+    def __call__(self):
+        return dict(self._specs)
+
+get_specs = GetSpecs(_specs)
+

{spells_mtg-0.5.1 → spells_mtg-0.5.3}/spells/draft_data.py

@@ -6,7 +6,6 @@ Aggregate dataframes containing raw counts are cached in the local file system
 for performance.
 """
 
-import datetime
 import functools
 import hashlib
 import re
@@ -20,7 +19,7 @@ from spells.external import data_file_path
 import spells.cache
 import spells.filter
 import spells.manifest
-from spells.columns import ColDef, ColSpec
+from spells.columns import ColDef, ColSpec, get_specs
 from spells.enums import View, ColName, ColType
 
 
@@ -356,16 +355,19 @@ def summon(
     columns: list[str] | None = None,
     group_by: list[str] | None = None,
     filter_spec: dict | None = None,
-    extensions: dict[str, ColSpec] | None = None,
+    extensions: dict[str, ColSpec] | list[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:
-    specs = dict(spells.columns.specs)
+    specs = get_specs()
 
     if extensions is not None:
-        specs.update(extensions)
+        if not isinstance(extensions, list):
+            extensions = [extensions]
+        for ext in extensions:
+            specs.update(ext)
 
     col_def_map = _hydrate_col_defs(set_code, specs, card_context)
     m = spells.manifest.create(col_def_map, columns, group_by, filter_spec)

{spells_mtg-0.5.1 → spells_mtg-0.5.3}/spells/enums.py

@@ -143,6 +143,7 @@ class ColName(StrEnum):
     GNS_WR = "gns_wr"
     IWD = "iwd"
     NUM_IN_POOL = "num_in_pool"
+    NUM_IN_POOL_TOTAL = "num_in_pool_total"
     IN_POOL_WR = "in_pool_wr"
     DECK_TOTAL = "deck_total"
     WON_DECK_TOTAL = "won_deck_total"

spells_mtg-0.5.3/spells/extension.py

@@ -0,0 +1,182 @@
+import math 
+
+import polars as pl
+
+from spells.enums import ColType, ColName
+from spells.columns import ColSpec
+from spells.cache import spells_print
+
+def print_ext(ext: dict[str, ColSpec]) -> None:
+    spells_print("create", "Created extensions:")
+    for key in ext:
+        print("\t" + key)
+
+
+def attr_cols(attr, silent=False) -> dict[str, ColSpec]:
+    ext = {
+        f"seen_{attr}": ColSpec(
+            col_type=ColType.NAME_SUM,
+            expr=(lambda name, card_context: pl.lit(None) if card_context[name][attr] is None or math.isnan(card_context[name][attr]) else 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: pl.lit(None) if card_context[name][attr] is None or math.isnan(card_context[name][attr]) else card_context[name][attr]
+        ),
+        f"seen_{attr}_greater": ColSpec(
+            col_type=ColType.NAME_SUM,
+            expr=lambda name: pl.col(f"seen_{attr}_{name}") > pl.col(f"pick_{attr}"),
+        ),
+        f"seen_{attr}_less": ColSpec(
+            col_type=ColType.NAME_SUM,
+            expr=lambda name: pl.col(f"seen_{attr}_{name}") < pl.col(f"pick_{attr}"),
+        ),
+        f"greatest_{attr}_seen": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=lambda names: pl.max_horizontal([pl.col(f"seen_{attr}_{name}") for name in names]),
+        ),
+        f"least_{attr}_seen": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=lambda names: pl.min_horizontal([pl.col(f"seen_{attr}_{name}") for name in names]),
+        ),
+        f"pick_{attr}_rank_greatest": ColSpec(
+            col_type=ColType.GROUP_BY,
+            expr=lambda names: pl.sum_horizontal([pl.col(f"seen_{attr}_greater_{name}") for name in names]) + 1,
+        ),
+        f"pick_{attr}_rank_least": ColSpec(
+            col_type=ColType.GROUP_BY,
+            expr=lambda names: pl.sum_horizontal([pl.col(f"seen_{attr}_less_{name}") for name in names]) + 1,
+        ),
+        f"pick_{attr}_rank_greatest_sum": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=pl.col(f"pick_{attr}_rank_greatest")
+        ),
+        f"pick_{attr}_rank_least_sum": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=pl.col(f"pick_{attr}_rank_least")
+        ),
+        f"pick_{attr}_vs_least": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=pl.col(f"pick_{attr}") - pl.col(f"least_{attr}_seen"),
+        ),
+        f"pick_{attr}_vs_greatest": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=pl.col(f"pick_{attr}") - pl.col(f"greatest_{attr}_seen"),
+        ),
+        f"pick_{attr}_vs_least_mean": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"pick_{attr}_vs_least") / pl.col(ColName.NUM_TAKEN),
+        ),
+        f"pick_{attr}_vs_greatest_mean": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"pick_{attr}_vs_greatest") / pl.col(ColName.NUM_TAKEN),
+        ),
+        f"least_{attr}_taken": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=pl.col(f'pick_{attr}') <= pl.col(f'least_{attr}_seen'),
+        ),
+        f"least_{attr}_taken_rate": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"least_{attr}_taken") / pl.col(ColName.NUM_TAKEN), 
+        ),
+        f"greatest_{attr}_taken": ColSpec(
+            col_type=ColType.PICK_SUM,
+            expr=pl.col(f'pick_{attr}') >= pl.col(f"greatest_{attr}_seen")
+        ),
+        f"greatest_{attr}_taken_rate": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"greatest_{attr}_taken") / pl.col(ColName.NUM_TAKEN), 
+        ),
+        f"pick_{attr}_mean": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"pick_{attr}") / pl.col(ColName.NUM_TAKEN)
+        ),
+        f"{attr}_deck_weight_group": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}") * pl.col(ColName.DECK)
+        ),
+        f"{attr}_deck_weight_total": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_deck_weight_group").sum()
+        ),
+        f"{attr}_dw_mean": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_deck_weight_total") / pl.col(ColName.DECK_TOTAL),
+        ),
+        f"{attr}_dw_excess": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_dw_mean") - pl.col(f"{attr}"),
+        ),
+        f"{attr}_dw_var": ColSpec(
+            col_type=ColType.AGG,
+            expr=(pl.col(f"{attr}_dw_excess").pow(2) * pl.col(ColName.DECK)) / pl.col(ColName.DECK_TOTAL),
+        ),
+        f"{attr}_dw_stdev": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_dw_var").sqrt(),
+        ),
+        f"{attr}_dwz": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_dw_excess") / pl.col(f"{attr}_dw_stdev"),
+        ),
+        f"{attr}_pool_weight_group": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}") * pl.col(ColName.NUM_IN_POOL)
+        ),
+        f"{attr}_pool_weight_total": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_pool_weight_group").sum()
+        ),
+        f"{attr}_pw_mean": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_pool_weight_total") / pl.col(ColName.NUM_IN_POOL_TOTAL),
+        ),
+        f"{attr}_pw_excess": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_pw_mean") - pl.col(f"{attr}"),
+        ),
+        f"{attr}_pw_var": ColSpec(
+            col_type=ColType.AGG,
+            expr=(pl.col(f"{attr}_pw_excess").pow(2) * pl.col(ColName.NUM_IN_POOL)) / pl.col(ColName.NUM_IN_POOL_TOTAL),
+        ),
+        f"{attr}_pw_stdev": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_pw_var").sqrt(),
+        ),
+        f"{attr}_pwz": ColSpec(
+            col_type=ColType.AGG,
+            expr=pl.col(f"{attr}_pw_excess") / pl.col(f"{attr}_pw_stdev"),
+        ),
+    }
+
+    if not silent:
+        print_ext(ext)
+
+    return ext
+
+def more(silent=True):
+    wr_bucket = pl.col(ColName.USER_GAME_WIN_RATE_BUCKET)
+    gp_bucket = pl.col(ColName.USER_N_GAMES_BUCKET)
+    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")
+        ),
+        'cohorts_plus': ColSpec(
+            col_type=ColType.GROUP_BY,
+            expr=pl.when((wr_bucket > 0.65) & (gp_bucket >= 500)).then(pl.lit('1 Best')).otherwise(
+                pl.when((wr_bucket > 0.61) & (gp_bucket >= 500) | (wr_bucket > 0.65) & (gp_bucket >= 100)).then(pl.lit('2 Elite')).otherwise(
+                    pl.when((wr_bucket > 0.57) & (gp_bucket >= 100) | (wr_bucket > 0.61)).then(pl.lit('3 Competitive')).otherwise(
+                        pl.when((wr_bucket > 0.53) & (gp_bucket >= 100) | (wr_bucket > 0.57)).then(pl.lit('4 Solid')).otherwise(pl.lit('5 None'))
+                    )
+                )
+            )
+        )
+    }
+
+    if not silent:
+        print_ext(ext)
+
+    return ext
+

spells_mtg-0.5.1/spells/extension.py

@@ -1,40 +0,0 @@
-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")
-        )
-    }