spells-mtg 0.0.1__py3-none-any.whl

spells/__init__.py

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

spells/cache.py

@@ -0,0 +1,106 @@
+"""
+Module for caching the result of distributed dataframe calculations to parquet files.
+
+Caches are keyed by a hash that is function of set code, aggregation type, base filter,
+and groupbys.
+
+Caches are cleared per-set when new files are downloaded.
+"""
+
+from enum import StrEnum
+import os
+import sys
+
+import polars as pl
+
+
+class DataDir(StrEnum):
+    CACHE = "cache"
+    EXTERNAL = "external"
+
+
+def spells_print(mode, content):
+    print(f"🪄 {mode} ✨ {content}")
+
+
+def data_home() -> str:
+    is_win = sys.platform == "win32"
+    return os.path.expanduser(
+        os.environ.get(
+            "SPELLS_DATA_HOME",
+            os.environ.get(
+                "XDG_DATA_HOME",
+                r"C:\Users\$USERNAME\AppData\Local\Spells"
+                if is_win
+                else "~/.local/share/spells/",
+            ),
+        )
+    )
+
+
+def data_dir_path(cache_dir: DataDir) -> str:
+    """
+    Where 17Lands data is stored. MDU_DATA_DIR environment variable is used, if it exists,
+    otherwise the cwd is used
+    """
+    is_win = sys.platform == "win32"
+
+    ext = {
+        DataDir.CACHE: "Cache" if is_win else "cache",
+        DataDir.EXTERNAL: "External" if is_win else "external",
+    }[cache_dir]
+
+    data_dir = os.path.join(data_home(), ext)
+    return data_dir
+
+
+def cache_dir_for_set(set_code: str) -> str:
+    return os.path.join(data_dir_path(DataDir.CACHE), set_code)
+
+
+def cache_path_for_key(set_code: str, cache_key: str) -> str:
+    return os.path.join(cache_dir_for_set(set_code), cache_key + ".parquet")
+
+
+def cache_exists(set_code: str, cache_key: str) -> bool:
+    return os.path.isdir(cache_dir_for_set(set_code)) and os.path.isfile(
+        cache_path_for_key(set_code, cache_key)
+    )
+
+
+def read_cache(set_code: str, cache_key: str) -> pl.DataFrame:
+    return pl.read_parquet(cache_path_for_key(set_code, cache_key))
+
+
+def write_cache(set_code: str, cache_key: str, df: pl.DataFrame) -> None:
+    cache_dir = cache_dir_for_set(set_code)
+    if not os.path.isdir(cache_dir):
+        os.makedirs(cache_dir)
+
+    df.write_parquet(cache_path_for_key(set_code, cache_key))
+
+
+def clear(set_code: str) -> int:
+    mode = "clean"
+    cache_dir = cache_dir_for_set(set_code)
+    if os.path.isdir(cache_dir):
+        with os.scandir(cache_dir) as set_dir:
+            count = 0
+            for entry in set_dir:
+                if not entry.name.endswith(".parquet"):
+                    spells_print(
+                        mode,
+                        f"Unexpected file {entry.name} found in local cache, please sort that out!",
+                    )
+                    return 1
+                count += 1
+                os.remove(entry)
+            spells_print(
+                mode, f"Removed {count} files from local cache for set {set_code}"
+            )
+        os.rmdir(cache_dir)
+        spells_print(mode, f"Removed local cache dir {cache_dir}")
+        return 0
+    else:
+        spells_print(mode, f"No local cache found for set {set_code}")
+        return 0

spells/cards.py

@@ -0,0 +1,96 @@
+import json
+import urllib.request
+from enum import StrEnum
+
+import polars as pl
+
+from spells.enums import ColName
+
+
+class CardAttr(StrEnum):
+    NAME = ColName.NAME
+    SET_CODE = ColName.SET_CODE
+    COLOR = ColName.COLOR
+    RARITY = ColName.RARITY
+    COLOR_IDENTITY = ColName.COLOR_IDENTITY
+    CARD_TYPE = ColName.CARD_TYPE
+    SUBTYPE = ColName.SUBTYPE
+    MANA_VALUE = ColName.MANA_VALUE
+    MANA_COST = ColName.MANA_COST
+    POWER = ColName.POWER
+    TOUGHNESS = ColName.TOUGHNESS
+    IS_BONUS_SHEET = ColName.IS_BONUS_SHEET
+    IS_DFC = ColName.IS_DFC
+
+
+MTG_JSON_TEMPLATE = "https://mtgjson.com/api/v5/{set_code}.json"
+
+
+def _fetch_mtg_json(set_code: str) -> dict:
+    request = urllib.request.Request(
+        MTG_JSON_TEMPLATE.format(set_code=set_code),
+        headers={"User-Agent": "spells-mtg/0.1.0"},
+    )
+
+    with urllib.request.urlopen(request) as f:
+        draft_set_json = json.loads(f.read().decode("utf-8"))
+
+    return draft_set_json
+
+
+def _extract_value(set_code: str, name: str, card_dict: dict, field: CardAttr):
+    match field:
+        case CardAttr.NAME:
+            return name
+        case CardAttr.SET_CODE:
+            return card_dict.get("setCode", "")
+        case CardAttr.COLOR:
+            return "".join(card_dict.get("colors", []))
+        case CardAttr.RARITY:
+            return card_dict.get("rarity", "")
+        case CardAttr.COLOR_IDENTITY:
+            return "".join(card_dict.get("colorIdentity", []))
+        case CardAttr.CARD_TYPE:
+            return " ".join(card_dict.get("types", []))
+        case CardAttr.SUBTYPE:
+            return " ".join(card_dict.get("subtypes", []))
+        case CardAttr.MANA_VALUE:
+            return card_dict.get("manaValue", 0)
+        case CardAttr.MANA_COST:
+            return card_dict.get("manaCost", "")
+        case CardAttr.POWER:
+            return card_dict.get("power", None)
+        case CardAttr.TOUGHNESS:
+            return card_dict.get("toughness", None)
+        case CardAttr.IS_BONUS_SHEET:
+            return card_dict.get("setCode", set_code) != set_code
+        case CardAttr.IS_DFC:
+            return len(card_dict.get("otherFaceIds", [])) > 0
+
+
+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"]
+    set_codes.reverse()
+
+    card_data_map = {}
+    for set_code in set_codes:
+        if set_code != draft_set_code:
+            card_data = _fetch_mtg_json(set_code)["data"]["cards"]
+        else:
+            card_data = draft_set_json["data"]["cards"]
+
+        card_data.reverse()  # prefer front face for split cards
+        face_name_cards = [item for item in card_data if "faceName" in item]
+        card_data_map.update({item["faceName"]: item for item in face_name_cards})
+        card_data_map.update({item["name"]: item for item in card_data})
+
+    return pl.DataFrame(
+        [
+            {
+                field: _extract_value(draft_set_code, name, card_data_map[name], field)
+                for field in CardAttr
+            }
+            for name in names
+        ]
+    )