spells-mtg 0.8.4__py3-none-any.whl → 0.9.1__py3-none-any.whl

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/cache.py

@@ -14,6 +14,11 @@ import sys
 import polars as pl
 
 
+class EventType(StrEnum):
+    PREMIER = "PremierDraft"
+    TRADITIONAL = "TradDraft"
+
+
 class DataDir(StrEnum):
     CACHE = "cache"
     EXTERNAL = "external"
@@ -52,6 +57,22 @@ def data_dir_path(cache_dir: DataDir) -> str:
     return data_dir
 
 
+def external_set_path(set_code):
+    return os.path.join(data_dir_path(DataDir.EXTERNAL), set_code)
+
+
+def data_file_path(set_code, dataset_type: str, event_type=EventType.PREMIER):
+    if dataset_type == "set_context":
+        return os.path.join(external_set_path(set_code), f"{set_code}_context.parquet")
+
+    if dataset_type == "card":
+        return os.path.join(external_set_path(set_code), f"{set_code}_card.parquet")
+
+    return os.path.join(
+        external_set_path(set_code), f"{set_code}_{event_type}_{dataset_type}.parquet"
+    )
+
+
 def cache_dir_for_set(set_code: str) -> str:
     return os.path.join(data_dir_path(DataDir.CACHE), set_code)
 

spells/columns.py

@@ -68,10 +68,7 @@ _specs: dict[str, ColSpec] = {
     ColName.FORMAT_DAY: ColSpec(
         col_type=ColType.GROUP_BY,
         expr=lambda set_context: (
-            pl.col(ColName.DRAFT_DATE)
-            - pl.lit(set_context["release_time"])
-            .str.to_datetime("%Y-%m-%d %H:%M:%S")
-            .dt.date()
+            pl.col(ColName.DRAFT_DATE) - pl.lit(set_context["release_date"])
         ).dt.total_days()
         + 1,
     ),
@@ -583,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/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
@@ -16,13 +17,12 @@ from typing import Callable, TypeVar, Any
 import polars as pl
 from polars.exceptions import ColumnNotFoundError
 
-from spells.external import data_file_path
-import spells.cache
+from spells import cache
 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)
 
@@ -36,11 +36,11 @@ def _cache_key(args) -> str:
 
 @functools.lru_cache(maxsize=None)
 def get_names(set_code: str) -> list[str]:
-    card_fp = data_file_path(set_code, View.CARD)
+    card_fp = cache.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())
 
-    draft_fp = data_file_path(set_code, View.DRAFT)
+    draft_fp = cache.data_file_path(set_code, View.DRAFT)
     draft_view = pl.scan_parquet(draft_fp)
     cols = draft_view.collect_schema().names()
 
@@ -78,13 +78,17 @@ def _get_card_context(
 
         columns = list(col_def_map.keys())
 
-        fp = data_file_path(set_code, View.CARD)
+        fp = cache.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()
 
+        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}
@@ -100,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
@@ -130,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)
@@ -223,7 +233,7 @@ def _infer_dependencies(
             ):
                 dependencies.add(split[0])
                 found = True
-        assert found, f"Could not locate column spec for root col {item}"
+        # fail silently here, so that columns can be passed in harmlessly
 
     return dependencies
 
@@ -231,23 +241,13 @@ def _infer_dependencies(
 def _get_set_context(
     set_code: str, set_context: pl.DataFrame | dict[str, Any] | None
 ) -> dict[str, Any]:
-    context_fp = data_file_path(set_code, "context")
-
-    report = functools.partial(
-        spells.cache.spells_print,
-        "report",
-        f"Set context for {set_code} invalid, please investigate!",
-    )
+    context_fp = cache.data_file_path(set_code, "context")
 
     context = {}
-    if not os.path.isfile(context_fp):
-        report()
-    else:
+    if os.path.isfile(context_fp):
         context_df = pl.read_parquet(context_fp)
         if len(context_df) == 1:
             context.update(context_df.to_dicts()[0])
-        else:
-            report()
 
     if isinstance(set_context, pl.DataFrame):
         assert len(set_context != 1), "Invalid set context provided"
@@ -355,13 +355,15 @@ def _fetch_or_cache(
     key = _cache_key(cache_args)
 
     if read_cache:
-        if spells.cache.cache_exists(set_code, key):
-            return spells.cache.read_cache(set_code, key)
+        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:
-        spells.cache.write_cache(set_code, key, df)
+        cache.write_cache(set_code, key, df)
 
     return df
 
@@ -380,7 +382,7 @@ def _base_agg_df(
     for view, cols_for_view in m.view_cols.items():
         if view == View.CARD:
             continue
-        df_path = data_file_path(set_code, view)
+        df_path = cache.data_file_path(set_code, view)
         base_view_df = pl.scan_parquet(df_path)
         base_df_prefilter = _view_select(
             base_view_df, cols_for_view, m.col_def_map, is_agg_view=False
@@ -411,14 +413,10 @@ def _base_agg_df(
             c for c in cols_for_view if m.col_def_map[c].col_type == ColType.NAME_SUM
         )
         for col in name_sum_cols:
-            cdef = m.col_def_map[col]
-            pattern = f"^{cdef.name}_"
-            name_map = functools.partial(
-                lambda patt, name: re.split(patt, name)[1], pattern
-            )
+            names = get_names(set_code)
+            expr = tuple(pl.col(f"{col}_{name}").alias(name) for name in names)
 
-            expr = pl.col(f"^{cdef.name}_.*$").name.map(name_map)
-            pre_agg_df = base_df.select((expr,) + nonname_gb)
+            pre_agg_df = base_df.select(expr + nonname_gb)
 
             if nonname_gb:
                 agg_df = pre_agg_df.group_by(nonname_gb).sum()
@@ -428,7 +426,7 @@ def _base_agg_df(
             index = nonname_gb if nonname_gb else None
             unpivoted = agg_df.unpivot(
                 index=index,
-                value_name=m.col_def_map[col].name,
+                value_name=col,
                 variable_name=ColName.NAME,
             )
 
@@ -452,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,
@@ -476,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
@@ -488,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):
@@ -523,7 +526,7 @@ def summon(
 
         if View.CARD in m.view_cols:
             card_cols = m.view_cols[View.CARD].union({ColName.NAME})
-            fp = data_file_path(code, View.CARD)
+            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
@@ -578,7 +581,7 @@ def view_select(
 
     col_def_map = _hydrate_col_defs(set_code, specs, card_context, set_context)
 
-    df_path = data_file_path(set_code, view)
+    df_path = cache.data_file_path(set_code, view)
     base_view_df = pl.scan_parquet(df_path)
 
     select_cols = frozenset(columns)

spells/extension.py

@@ -19,19 +19,23 @@ 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])
                 .otherwise(None)
             ),
         ),
-        f"pick_{attr}": 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(
+            col_type=ColType.AGG, expr=pl.col(f"pick_{attr}_sum") / pl.col("num_taken")
+        ),
         f"seen_{attr}_is_greatest": ColSpec(
             col_type=ColType.NAME_SUM,
             expr=lambda name: pl.col(f"seen_{attr}_{name}")
@@ -39,11 +43,13 @@ def context_cols(attr, silent: bool = False) -> dict[str, ColSpec]:
         ),
         f"seen_{attr}_greater": ColSpec(
             col_type=ColType.NAME_SUM,
-            expr=lambda name: pl.col(f"seen_{attr}_{name}") > pl.col(f"pick_{attr}"),
+            expr=lambda name: pl.col(f"seen_{attr}_{name}")
+            > pl.col(f"pick_{attr}_sum"),
         ),
         f"seen_{attr}_less": ColSpec(
             col_type=ColType.NAME_SUM,
-            expr=lambda name: pl.col(f"seen_{attr}_{name}") < pl.col(f"pick_{attr}"),
+            expr=lambda name: pl.col(f"seen_{attr}_{name}")
+            < pl.col(f"pick_{attr}_sum"),
         ),
         f"greatest_{attr}_seen": ColSpec(
             col_type=ColType.PICK_SUM,
@@ -79,11 +85,11 @@ def context_cols(attr, silent: bool = False) -> dict[str, ColSpec]:
         ),
         f"pick_{attr}_vs_least": ColSpec(
             col_type=ColType.PICK_SUM,
-            expr=pl.col(f"pick_{attr}") - pl.col(f"least_{attr}_seen"),
+            expr=pl.col(f"pick_{attr}_sum") - 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"),
+            expr=pl.col(f"pick_{attr}_sum") - pl.col(f"greatest_{attr}_seen"),
         ),
         f"pick_{attr}_vs_least_mean": ColSpec(
             col_type=ColType.AGG,
@@ -95,7 +101,7 @@ def context_cols(attr, silent: bool = False) -> dict[str, ColSpec]:
         ),
         f"least_{attr}_taken": ColSpec(
             col_type=ColType.PICK_SUM,
-            expr=pl.col(f"pick_{attr}") <= pl.col(f"least_{attr}_seen"),
+            expr=pl.col(f"pick_{attr}_sum") <= pl.col(f"least_{attr}_seen"),
         ),
         f"least_{attr}_taken_rate": ColSpec(
             col_type=ColType.AGG,
@@ -103,7 +109,7 @@ def context_cols(attr, silent: bool = False) -> dict[str, ColSpec]:
         ),
         f"greatest_{attr}_taken": ColSpec(
             col_type=ColType.PICK_SUM,
-            expr=pl.col(f"pick_{attr}") >= pl.col(f"greatest_{attr}_seen"),
+            expr=pl.col(f"pick_{attr}_sum") >= pl.col(f"greatest_{attr}_seen"),
         ),
         f"greatest_{attr}_taken_rate": ColSpec(
             col_type=ColType.AGG,
@@ -111,7 +117,7 @@ def context_cols(attr, silent: bool = False) -> dict[str, ColSpec]:
         ),
         f"pick_{attr}_mean": ColSpec(
             col_type=ColType.AGG,
-            expr=pl.col(f"pick_{attr}") / pl.col(ColName.NUM_TAKEN),
+            expr=pl.col(f"pick_{attr}_sum") / pl.col(ColName.NUM_TAKEN),
         ),
     }
 

spells/external.py

@@ -19,8 +19,9 @@ from polars.exceptions import ComputeError
 
 from spells import cards
 from spells import cache
-from spells.enums import View
+from spells.enums import View, ColName
 from spells.schema import schema
+from spells.draft_data import summon
 
 
 DATASET_TEMPLATE = "{dataset_type}_data_public.{set_code}.{event_type}.csv.gz"
@@ -34,11 +35,6 @@ class FileFormat(StrEnum):
     PARQUET = "parquet"
 
 
-class EventType(StrEnum):
-    PREMIER = "PremierDraft"
-    TRADITIONAL = "TradDraft"
-
-
 # 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"):
@@ -64,7 +60,7 @@ def cli() -> int:
         e.g. $ spells add OTJ
 
     refresh: Force download and overwrite of existing files (for new data drops, use sparingly!). Clear 
-        local cache.
+        local 
 
     remove: Delete the [data home]/external/[set code] and [data home]/local/[set code] directories and their contents
 
@@ -115,7 +111,7 @@ def _refresh(set_code: str):
 
 def _remove(set_code: str):
     mode = "remove"
-    dir_path = _external_set_path(set_code)
+    dir_path = cache.external_set_path(set_code)
     if os.path.isdir(dir_path):
         with os.scandir(dir_path) as set_dir:
             count = 0
@@ -135,7 +131,7 @@ def _remove(set_code: str):
     else:
         cache.spells_print(mode, f"No external cache found for set {set_code}")
 
-    return cache.clear(set_code)
+    return cache.clean(set_code)
 
 
 def _info():
@@ -207,22 +203,6 @@ def _info():
     return 0
 
 
-def _external_set_path(set_code):
-    return os.path.join(cache.data_dir_path(cache.DataDir.EXTERNAL), set_code)
-
-
-def data_file_path(set_code, dataset_type: str, event_type=EventType.PREMIER):
-    if dataset_type == "set_context":
-        return os.path.join(_external_set_path(set_code), f"{set_code}_context.parquet")
-
-    if dataset_type == "card":
-        return os.path.join(_external_set_path(set_code), f"{set_code}_card.parquet")
-
-    return os.path.join(
-        _external_set_path(set_code), f"{set_code}_{event_type}_{dataset_type}.parquet"
-    )
-
-
 def _process_zipped_file(gzip_path, target_path):
     csv_path = gzip_path[:-3]
     # if polars supports streaming from file obj, we can just stream straight
@@ -252,17 +232,17 @@ def _process_zipped_file(gzip_path, target_path):
 def download_data_set(
     set_code,
     dataset_type: View,
-    event_type=EventType.PREMIER,
+    event_type=cache.EventType.PREMIER,
     force_download=False,
     clear_set_cache=True,
 ):
     mode = "refresh" if force_download else "add"
     cache.spells_print(mode, f"Downloading {dataset_type} dataset from 17Lands.com")
 
-    if not os.path.isdir(set_dir := _external_set_path(set_code)):
+    if not os.path.isdir(set_dir := cache.external_set_path(set_code)):
         os.makedirs(set_dir)
 
-    target_path = data_file_path(set_code, dataset_type)
+    target_path = cache.data_file_path(set_code, dataset_type)
 
     if os.path.isfile(target_path) and not force_download:
         cache.spells_print(
@@ -274,7 +254,7 @@ def download_data_set(
     dataset_file = DATASET_TEMPLATE.format(
         set_code=set_code, dataset_type=dataset_type, event_type=event_type
     )
-    dataset_path = os.path.join(_external_set_path(set_code), dataset_file)
+    dataset_path = os.path.join(cache.external_set_path(set_code), dataset_file)
     wget.download(
         RESOURCE_TEMPLATE.format(dataset_type=dataset_type) + dataset_file,
         out=dataset_path,
@@ -287,7 +267,7 @@ def download_data_set(
     _process_zipped_file(dataset_path, target_path)
     cache.spells_print(mode, f"Wrote file {target_path}")
     if clear_set_cache:
-        cache.clear(set_code)
+        cache.clean(set_code)
 
     return 0
 
@@ -302,7 +282,7 @@ def write_card_file(draft_set_code: str, force_download=False) -> int:
     cache.spells_print(
         mode, "Fetching card data from mtgjson.com and writing card file"
     )
-    card_filepath = data_file_path(draft_set_code, View.CARD)
+    card_filepath = cache.data_file_path(draft_set_code, View.CARD)
     if os.path.isfile(card_filepath) and not force_download:
         cache.spells_print(
             mode,
@@ -310,7 +290,7 @@ def write_card_file(draft_set_code: str, force_download=False) -> int:
         )
         return 1
 
-    draft_filepath = data_file_path(draft_set_code, View.DRAFT)
+    draft_filepath = cache.data_file_path(draft_set_code, View.DRAFT)
 
     if not os.path.isfile(draft_filepath):
         cache.spells_print(mode, f"Error: No draft file for set {draft_set_code}")
@@ -336,7 +316,7 @@ def write_card_file(draft_set_code: str, force_download=False) -> int:
 def get_set_context(set_code: str, force_download=False) -> int:
     mode = "refresh" if force_download else "add"
 
-    context_fp = data_file_path(set_code, "context")
+    context_fp = cache.data_file_path(set_code, "context")
     cache.spells_print(mode, "Calculating set context")
     if os.path.isfile(context_fp) and not force_download:
         cache.spells_print(
@@ -345,15 +325,18 @@ def get_set_context(set_code: str, force_download=False) -> int:
         )
         return 1
 
-    draft_fp = data_file_path(set_code, View.DRAFT)
-    draft_view = pl.scan_parquet(draft_fp)
+    df = summon(
+        set_code,
+        columns=[ColName.NUM_DRAFTS],
+        group_by=[ColName.DRAFT_DATE, ColName.PICK_NUM],
+    )
 
-    context_df = draft_view.select(
+    context_df = df.filter(pl.col(ColName.NUM_DRAFTS) > 1000).select(
         [
-            pl.max("pick_number").alias("picks_per_pack") + 1,
-            pl.min("draft_time").alias("release_time"),
+            pl.col(ColName.DRAFT_DATE).min().alias("release_date"),
+            pl.col(ColName.PICK_NUM).max().alias("picks_per_pack"),
         ]
-    ).collect()
+    )
 
     context_df.write_parquet(context_fp)
 

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(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

{spells_mtg-0.8.4.dist-info → spells_mtg-0.9.1.dist-info}/METADATA

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

spells_mtg-0.9.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+spells/__init__.py,sha256=bpxhRijyI-wxLPRVNathM9N9Cpq3E8uBSqWyYpDGFAI,275
+spells/cache.py,sha256=JTFA31quGUL8pxy04NLWjEhQd5GEp37Q4PWUMnMuUJU,3797
+spells/cards.py,sha256=EOXAB_F2yedjf6KquCERCIHl0TSIJIoOe1jv8g4JzOc,3601
+spells/columns.py,sha256=PztPNLtqKIqIQdiCHYykk7bcYlx0_QRypu3WOsSZb-A,17856
+spells/config.py,sha256=HDelOKrEbgMIAJfSGqzJbZdf-sInMZXRD-BI2j0QnZI,180
+spells/draft_data.py,sha256=_gzxlpnKa5WlxTfwdnxJhvFvGsTY69bCl0cOe4VRlaI,19271
+spells/enums.py,sha256=DL7e1xDEvrsTMbA7vJB_Et1DaYkyO4rIEzvIQDz3MZk,4871
+spells/extension.py,sha256=DVzIedggeGfkD6BD5g-dko9l9BoPgmXWvcQ3NWdEG0U,6991
+spells/external.py,sha256=T34oqhyM5cIFvMAMJwlltdFS4CDeouVMbU-6My60OLg,11305
+spells/filter.py,sha256=J-YTOOAzOQpvIX29tviYL04RVoOUlfsbjBXoQBDCEdQ,3380
+spells/log.py,sha256=-GnocAZ7K-032QohHCY5vC2myRhumuUQCTuq1erTmL4,1819
+spells/manifest.py,sha256=dOUmj2uZZ17vCWpFwv7B5F6wOIWnoQdZkEB9SDKdx9M,8310
+spells/schema.py,sha256=DbMvV8PIThJTp0Xzp_XIorlW6JhE1ud1kWRGf5SQ4_c,6406
+spells_mtg-0.9.1.dist-info/METADATA,sha256=VcOjIXJ0q-qvg5aVOW-cwO3PfmV4b3DBhKuC5vY_xLc,46731
+spells_mtg-0.9.1.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+spells_mtg-0.9.1.dist-info/entry_points.txt,sha256=a9Y1omdl9MdnKuIj3aOodgrp-zZII6OCdvqwgP6BFvI,63
+spells_mtg-0.9.1.dist-info/licenses/LICENSE,sha256=tS54XYbJSgmq5zuHhbsQGbNQLJPVgXqhF5nu2CSRMig,1068
+spells_mtg-0.9.1.dist-info/RECORD,,

spells_mtg-0.8.4.dist-info/RECORD

@@ -1,17 +0,0 @@
-spells/__init__.py,sha256=dWkRW298GOYHFiG84S3cUrp4R-vydgA-v95CFPaWu2M,221
-spells/cache.py,sha256=YpTmlW-U2EosvGCH9gRQdQc8gRjjcGbgQovn5gfA_WE,3165
-spells/cards.py,sha256=EOXAB_F2yedjf6KquCERCIHl0TSIJIoOe1jv8g4JzOc,3601
-spells/columns.py,sha256=SdNw51lA1ox5rD2M7F8M2yqo-m0Dal5sKzS4Rp4q9MQ,18092
-spells/config.py,sha256=HDelOKrEbgMIAJfSGqzJbZdf-sInMZXRD-BI2j0QnZI,180
-spells/draft_data.py,sha256=R44E8eb7bMOT0AxnkWcOAyuVCLDUxbvYmlYCLEtqi-s,18800
-spells/enums.py,sha256=DL7e1xDEvrsTMbA7vJB_Et1DaYkyO4rIEzvIQDz3MZk,4871
-spells/extension.py,sha256=o0IeCrafo7HhNBT7fSEMF-y0Vi1zu-8uUu_0EIj9-5U,6783
-spells/external.py,sha256=PN0PkwdKnvx-4HkApFhI1_ZwRvBUDMUd3Vfbky0xSJA,11786
-spells/filter.py,sha256=J-YTOOAzOQpvIX29tviYL04RVoOUlfsbjBXoQBDCEdQ,3380
-spells/manifest.py,sha256=dOUmj2uZZ17vCWpFwv7B5F6wOIWnoQdZkEB9SDKdx9M,8310
-spells/schema.py,sha256=DbMvV8PIThJTp0Xzp_XIorlW6JhE1ud1kWRGf5SQ4_c,6406
-spells_mtg-0.8.4.dist-info/METADATA,sha256=9szmimCDBYLOQcy4wfdi8E6tAoxe1Bt_KLjF_coyXkY,46731
-spells_mtg-0.8.4.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-spells_mtg-0.8.4.dist-info/entry_points.txt,sha256=a9Y1omdl9MdnKuIj3aOodgrp-zZII6OCdvqwgP6BFvI,63
-spells_mtg-0.8.4.dist-info/licenses/LICENSE,sha256=tS54XYbJSgmq5zuHhbsQGbNQLJPVgXqhF5nu2CSRMig,1068
-spells_mtg-0.8.4.dist-info/RECORD,,