spells-mtg 0.9.0__tar.gz → 0.9.2__tar.gz

{spells_mtg-0.9.0 → spells_mtg-0.9.2}/PKG-INFO

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

{spells_mtg-0.9.0 → spells_mtg-0.9.2}/pyproject.toml

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

{spells_mtg-0.9.0 → spells_mtg-0.9.2}/spells/__init__.py

@@ -1,5 +1,8 @@
 from spells.columns import ColSpec
 from spells.enums import ColType, ColName
 from spells.draft_data import summon, view_select, get_names
+from spells.log import setup_logging
+
+setup_logging()
 
 __all__ = ["summon", "view_select", "get_names", "ColSpec", "ColType", "ColName"]

{spells_mtg-0.9.0 → spells_mtg-0.9.2}/spells/columns.py

@@ -580,12 +580,5 @@ for item in ColName:
     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)
+def get_specs():
+    return dict(_specs)

{spells_mtg-0.9.0 → spells_mtg-0.9.2}/spells/draft_data.py

@@ -9,6 +9,7 @@ for performance.
 import functools
 import hashlib
 import re
+import logging
 from inspect import signature
 import os
 from typing import Callable, TypeVar, Any
@@ -21,7 +22,7 @@ import spells.filter
 import spells.manifest
 from spells.columns import ColDef, ColSpec, get_specs
 from spells.enums import View, ColName, ColType
-
+from spells.log import make_verbose
 
 DF = TypeVar("DF", pl.LazyFrame, pl.DataFrame)
 
@@ -83,7 +84,11 @@ def _get_card_context(
             card_df, frozenset(columns), col_def_map, is_agg_view=False
         ).to_dicts()
 
+        names = get_names(set_code)
         loaded_context = {row[ColName.NAME]: row for row in select_rows}
+
+        for name in names:
+            loaded_context[name] = loaded_context.get(name, {})
     else:
         names = get_names(set_code)
         loaded_context = {name: {} for name in names}
@@ -99,10 +104,7 @@ def _get_card_context(
 
         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():
+            for col, value in card_context.get(name, {}).items():
                 loaded_context[name][col] = value
 
     return loaded_context
@@ -129,46 +131,55 @@ def _determine_expression(
 
     if spec.col_type == ColType.NAME_SUM:
         if spec.expr is not None:
-            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"{col}_{name}"),
-                    unnamed_exprs,
-                    names,
+            try:
+                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"{col}_{name}"),
+                        unnamed_exprs,
+                        names,
+                    )
                 )
-            )
+            except KeyError:
+                expr = tuple(pl.lit(None).alias(f"{col}_{name}") for name in names)
         else:
             expr = tuple(map(lambda name: pl.col(f"{col}_{name}"), names))
 
     elif spec.expr is not None:
         if isinstance(spec.expr, Callable):
-            assert (
-                not spec.col_type == ColType.AGG
-            ), f"AGG column {col} must be a pure spells expression"
-            params = seed_params(spec.expr)
-            if (
-                spec.col_type in (ColType.PICK_SUM, ColType.CARD_ATTR)
-                and "name" in signature(spec.expr).parameters
-            ):
-                condition_col = (
-                    ColName.PICK if spec.col_type == ColType.PICK_SUM else ColName.NAME
-                )
-                expr = pl.lit(None)
-                for name in names:
-                    name_params = {"name": name, **params}
-                    expr = (
-                        pl.when(pl.col(condition_col) == name)
-                        .then(spec.expr(**name_params))
-                        .otherwise(expr)
+            try:
+                assert (
+                    not spec.col_type == ColType.AGG
+                ), f"AGG column {col} must be a pure spells expression"
+                params = seed_params(spec.expr)
+                if (
+                    spec.col_type in (ColType.PICK_SUM, ColType.CARD_ATTR)
+                    and "name" in signature(spec.expr).parameters
+                ):
+                    condition_col = (
+                        ColName.PICK
+                        if spec.col_type == ColType.PICK_SUM
+                        else ColName.NAME
                     )
-            else:
-                expr = spec.expr(**params)
+                    expr = pl.lit(None)
+                    for name in names:
+                        name_params = {"name": name, **params}
+                        expr = (
+                            pl.when(pl.col(condition_col) == name)
+                            .then(spec.expr(**name_params))
+                            .otherwise(expr)
+                        )
+                else:
+                    expr = spec.expr(**params)
+            except KeyError:
+                expr = pl.lit(None)
         else:
             expr = spec.expr
         expr = expr.alias(col)
@@ -265,10 +276,7 @@ def _hydrate_col_defs(
     assert len(names) > 0, "there should be names"
     hydrated = {}
     for col, spec in specs.items():
-        try:
-            expr = _determine_expression(col, spec, names, card_context, set_context)
-        except KeyError:
-            continue
+        expr = _determine_expression(col, spec, names, card_context, set_context)
         dependencies = _infer_dependencies(col, expr, specs, names)
 
         sig_expr = expr if isinstance(expr, pl.Expr) else expr[0]
@@ -348,8 +356,10 @@ def _fetch_or_cache(
 
     if read_cache:
         if cache.cache_exists(set_code, key):
+            logging.debug(f"Cache {key} found")
             return cache.read_cache(set_code, key)
 
+    logging.debug(f"Cache not found, calculating with signature {cache_args}")
     df = calc_fn()
 
     if write_cache:
@@ -440,9 +450,11 @@ def _base_agg_df(
     else:
         joined_df = pl.concat(join_dfs, how="horizontal")
 
+    joined_df = joined_df.select(sorted(joined_df.schema.names()))
     return joined_df
 
 
+@make_verbose
 def summon(
     set_code: str | list[str],
     columns: list[str] | None = None,
@@ -464,8 +476,10 @@ def summon(
             specs.update(ext)
 
     if isinstance(set_code, str):
-        card_context = {set_code: card_context}
-        set_context = {set_code: set_context}
+        if not (isinstance(card_context, dict) and set_code in card_context):
+            card_context = {set_code: card_context}
+        if not (isinstance(set_context, dict) and set_code in set_context):
+            set_context = {set_code: set_context}
         codes = [set_code]
     else:
         codes = set_code
@@ -476,6 +490,7 @@ def summon(
 
     concat_dfs = []
     for code in codes:
+        logging.debug(f"Calculating agg df for {code}")
         if isinstance(card_context, pl.DataFrame):
             set_card_context = card_context.filter(pl.col("expansion") == code)
         elif isinstance(card_context, dict):

{spells_mtg-0.9.0 → spells_mtg-0.9.2}/spells/extension.py

@@ -19,7 +19,7 @@ def context_cols(attr, silent: bool = False) -> dict[str, ColSpec]:
             col_type=ColType.NAME_SUM,
             expr=(
                 lambda name, card_context: pl.lit(None)
-                if card_context[name][attr] is None
+                if card_context[name].get(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])
@@ -29,7 +29,8 @@ def context_cols(attr, silent: bool = False) -> dict[str, ColSpec]:
         f"pick_{attr}_sum": 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])
+            if card_context[name].get(attr) is None
+            or math.isnan(card_context[name][attr])
             else card_context[name][attr],
         ),
         f"pick_{attr}": ColSpec(

{spells_mtg-0.9.0 → spells_mtg-0.9.2}/spells/external.py

@@ -29,10 +29,12 @@ RESOURCE_TEMPLATE = (
     "https://17lands-public.s3.amazonaws.com/analysis_data/{dataset_type}_data/"
 )
 
+
 class FileFormat(StrEnum):
     CSV = "csv"
     PARQUET = "parquet"
 
+
 # Fred Cirera via https://stackoverflow.com/questions/1094841/get-a-human-readable-version-of-a-file-size
 def sizeof_fmt(num, suffix="B"):
     for unit in ("", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"):
@@ -98,7 +100,7 @@ def cli() -> int:
 def _add(set_code: str, force_download=False):
     download_data_set(set_code, View.DRAFT, force_download=force_download)
     write_card_file(set_code, force_download=force_download)
-    get_set_context(set_code)
+    get_set_context(set_code, force_download=force_download)
     download_data_set(set_code, View.GAME, force_download=force_download)
     return 0
 
@@ -323,7 +325,11 @@ def get_set_context(set_code: str, force_download=False) -> int:
         )
         return 1
 
-    df = summon(set_code, columns=[ColName.NUM_DRAFTS], group_by=[ColName.DRAFT_DATE, ColName.PICK_NUM])
+    df = summon(
+        set_code,
+        columns=[ColName.NUM_DRAFTS],
+        group_by=[ColName.DRAFT_DATE, ColName.PICK_NUM],
+    )
 
     context_df = df.filter(pl.col(ColName.NUM_DRAFTS) > 1000).select(
         [

spells_mtg-0.9.2/spells/log.py

@@ -0,0 +1,68 @@
+from contextlib import contextmanager
+import logging
+import logging.handlers
+from pathlib import Path
+import sys
+from typing import Callable
+
+from spells.cache import data_home
+
+
+def setup_logging(
+    log_level=logging.DEBUG,
+    log_file_name="spells.log",
+    max_bytes=5_000_000,  # 5MB
+    backup_count=3,
+    log_format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+):
+    log_dir = Path(data_home()) / ".logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file_path = log_dir / log_file_name
+
+    handler = logging.handlers.RotatingFileHandler(
+        filename=log_file_path, maxBytes=max_bytes, backupCount=backup_count
+    )
+
+    formatter = logging.Formatter(log_format)
+    handler.setFormatter(formatter)
+
+    root_logger = logging.getLogger()
+    root_logger.setLevel(log_level)
+
+    root_logger.handlers.clear()
+    root_logger.addHandler(handler)
+
+
+def rotate_logs():
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers:
+        if isinstance(handler, logging.handlers.RotatingFileHandler):
+            handler.doRollover()
+            logging.debug("Log file manually rotated")
+
+
+@contextmanager
+def add_console_logging():
+    console_handler = logging.StreamHandler(sys.stdout)
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    console_handler.setFormatter(formatter)
+    logger = logging.getLogger()
+    logger.addHandler(console_handler)
+
+    try:
+        yield
+    finally:
+        logger.removeHandler(console_handler)
+
+
+def make_verbose(callable: Callable) -> Callable:
+    def wrapped(*args, verbose=False, **kwargs):
+        if verbose:
+            with add_console_logging():
+                return callable(*args, **kwargs)
+        else:
+            return callable(*args, **kwargs)
+
+    return wrapped