scorebook 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

scorebook/trismik/upload_results.py

@@ -0,0 +1,254 @@
+"""Upload evaluation and scoring results to Trismik's experimentation platform."""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from trismik.types import (
+    TrismikClassicEvalItem,
+    TrismikClassicEvalMetric,
+    TrismikClassicEvalRequest,
+    TrismikClassicEvalResponse,
+)
+
+from scorebook.evaluate.evaluate_helpers import (
+    create_trismik_async_client,
+    create_trismik_sync_client,
+    get_model_name,
+    normalize_metric_value,
+)
+
+logger = logging.getLogger(__name__)
+
+# Known fields that are not metrics or hyperparameters
+KNOWN_AGGREGATE_FIELDS = {"dataset", "run_id", "run_completed"}
+KNOWN_ITEM_FIELDS = {"id", "dataset_name", "input", "output", "label", "run_id"}
+
+
+def upload_result(
+    run_result: Dict[str, List[Dict[str, Any]]],
+    experiment_id: str,
+    project_id: str,
+    dataset_name: Optional[str] = None,
+    hyperparameters: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    model_name: Optional[str] = None,
+) -> str:
+    """Upload evaluation or scoring results to Trismik's platform (synchronous).
+
+    This function uploads results in the format returned by the evaluate or score
+    functions to the Trismik platform for tracking and analysis.
+
+    Args:
+        run_result: Dict with keys 'aggregate_results' and 'item_results' containing
+            evaluation/scoring results. Structure matches the output of evaluate()/score().
+        experiment_id: Trismik experiment identifier
+        project_id: Trismik project identifier
+        dataset_name: Optional dataset name. If not provided, extracted from metadata
+            or defaults to "Dataset"
+        hyperparameters: Optional dict of hyperparameters. If not provided, extracted
+            from run_result.
+        metadata: Optional metadata dict (can include 'model' and 'dataset' keys)
+        model_name: Optional model name. If not provided, extracted from metadata
+            or defaults to "Model"
+
+    Returns:
+        str: Run ID assigned by Trismik
+
+    Raises:
+        Exception: If upload fails (re-raises underlying exceptions)
+    """
+    # Create Trismik client
+    trismik_client = create_trismik_sync_client()
+
+    # Get model name - use provided model_name, or extract from metadata, or use default
+    if model_name is not None:
+        model = model_name
+    else:
+        model = get_model_name(metadata=metadata)
+
+    # Get dataset name - use provided dataset_name, or extract from metadata, or use default
+    if dataset_name is None:
+        if metadata and "dataset" in metadata:
+            dataset_name = str(metadata["dataset"])
+        else:
+            dataset_name = "Dataset"
+
+    # Extract aggregate and item results
+    aggregate_results = run_result.get("aggregate_results", [])
+    item_results = run_result.get("item_results", [])
+
+    # Use provided hyperparameters or default to empty dict
+    # Note: We don't extract hyperparameters from aggregate_results to avoid
+    # misclassifying metrics as hyperparameters
+    if hyperparameters is None:
+        hyperparameters = {}
+
+    # Create eval items from item_results
+    trismik_items: List[TrismikClassicEvalItem] = []
+    for item in item_results:
+        # Extract inputs, outputs, labels
+        item_id = str(item.get("id", 0))
+        model_input = str(item.get("input", ""))
+        model_output = str(item.get("output", ""))
+        gold_output = str(item.get("label", ""))
+
+        # Extract item-level metrics (exclude known fields and hyperparameters)
+        item_metrics: Dict[str, Any] = {}
+        for key, value in item.items():
+            if key not in KNOWN_ITEM_FIELDS and key not in (hyperparameters or {}):
+                # Normalize metric value for API compatibility
+                item_metrics[key] = normalize_metric_value(value)
+
+        eval_item = TrismikClassicEvalItem(  # pragma: allowlist secret
+            datasetItemId=item_id,
+            modelInput=model_input,
+            modelOutput=model_output,
+            goldOutput=gold_output,
+            metrics=item_metrics,
+        )
+        trismik_items.append(eval_item)
+
+    # Extract aggregate metrics from aggregate_results
+    trismik_metrics: List[TrismikClassicEvalMetric] = []
+    if aggregate_results:
+        for key, value in aggregate_results[0].items():
+            if key not in KNOWN_AGGREGATE_FIELDS and key not in (hyperparameters or {}):
+                # This is a metric  # pragma: allowlist secret
+                metric = TrismikClassicEvalMetric(metricId=key, value=normalize_metric_value(value))
+                trismik_metrics.append(metric)  # pragma: allowlist secret
+
+    # Create classic eval request
+    classic_eval_request = TrismikClassicEvalRequest(
+        project_id,
+        experiment_id,
+        dataset_name,
+        model,
+        hyperparameters,
+        trismik_items,
+        trismik_metrics,
+    )
+
+    # Submit to Trismik  # pragma: allowlist secret
+    response: TrismikClassicEvalResponse = trismik_client.submit_classic_eval(
+        classic_eval_request
+    )  # pragma: allowlist secret
+
+    run_id: str = response.id
+    logger.info(f"Run result uploaded successfully to Trismik with run_id: {run_id}")
+
+    return run_id
+
+
+async def upload_result_async(
+    run_result: Dict[str, List[Dict[str, Any]]],
+    experiment_id: str,
+    project_id: str,
+    dataset_name: Optional[str] = None,
+    hyperparameters: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    model_name: Optional[str] = None,
+) -> str:
+    """Upload evaluation or scoring results to Trismik's platform (asynchronous).
+
+    This function uploads results in the format returned by the evaluate or
+    score functions to the Trismik platform for tracking and analysis.
+
+    Args:
+        run_result: Dict with keys 'aggregate_results' and 'item_results' containing
+            evaluation/scoring results. Structure matches the output of evaluate()/score().
+        experiment_id: Trismik experiment identifier
+        project_id: Trismik project identifier
+        dataset_name: Optional dataset name. If not provided, extracted from metadata
+        or defaults to "Dataset"
+        hyperparameters: Optional dict of hyperparameters. If not provided, extracted
+            from run_result.
+        metadata: Optional metadata dict (can include 'model' and 'dataset' keys)
+        model_name: Optional model name. If not provided, extracted from metadata
+            or defaults to "Model"
+
+    Returns:
+        str: Run ID assigned by Trismik
+
+    Raises:
+        Exception: If upload fails (re-raises underlying exceptions)
+    """
+    # Create Trismik async client
+    trismik_client = create_trismik_async_client()
+
+    # Get model name - use provided model_name, or extract from metadata, or use default
+    if model_name is not None:
+        model = model_name
+    else:
+        model = get_model_name(metadata=metadata)
+
+    # Get dataset name - use provided dataset_name, or extract from metadata, or use default
+    if dataset_name is None:
+        if metadata and "dataset" in metadata:
+            dataset_name = str(metadata["dataset"])
+        else:
+            dataset_name = "Dataset"
+
+    # Extract aggregate and item results
+    aggregate_results = run_result.get("aggregate_results", [])
+    item_results = run_result.get("item_results", [])
+
+    # Use provided hyperparameters or default to empty dict
+    # Note: We don't extract hyperparameters from aggregate_results to avoid
+    # misclassifying metrics as hyperparameters
+    if hyperparameters is None:
+        hyperparameters = {}
+
+    # Create eval items from item_results
+    trismik_items: List[TrismikClassicEvalItem] = []
+    for item in item_results:
+        # Extract inputs, outputs, labels
+        item_id = str(item.get("id", 0))
+        model_input = str(item.get("input", ""))
+        model_output = str(item.get("output", ""))
+        gold_output = str(item.get("label", ""))
+
+        # Extract item-level metrics (exclude known fields and hyperparameters)
+        item_metrics: Dict[str, Any] = {}
+        for key, value in item.items():
+            if key not in KNOWN_ITEM_FIELDS and key not in (hyperparameters or {}):
+                # Normalize metric value for API compatibility
+                item_metrics[key] = normalize_metric_value(value)
+
+        eval_item = TrismikClassicEvalItem(  # pragma: allowlist secret
+            datasetItemId=item_id,
+            modelInput=model_input,
+            modelOutput=model_output,
+            goldOutput=gold_output,
+            metrics=item_metrics,
+        )
+        trismik_items.append(eval_item)
+
+    # Extract aggregate metrics from aggregate_results
+    trismik_metrics: List[TrismikClassicEvalMetric] = []
+    if aggregate_results:
+        for key, value in aggregate_results[0].items():
+            if key not in KNOWN_AGGREGATE_FIELDS and key not in (hyperparameters or {}):
+                # This is a metric  # pragma: allowlist secret
+                metric = TrismikClassicEvalMetric(metricId=key, value=normalize_metric_value(value))
+                trismik_metrics.append(metric)  # pragma: allowlist secret
+
+    # Create classic eval request
+    classic_eval_request = TrismikClassicEvalRequest(
+        project_id,
+        experiment_id,
+        dataset_name,
+        model,
+        hyperparameters,
+        trismik_items,
+        trismik_metrics,
+    )
+
+    # Submit to Trismik (async)  # pragma: allowlist secret
+    response: TrismikClassicEvalResponse = await trismik_client.submit_classic_eval(
+        classic_eval_request
+    )  # pragma: allowlist secret
+
+    run_id: str = response.id
+    logger.info(f"Run result uploaded successfully to Trismik with run_id: {run_id}")
+
+    return run_id

scorebook/types.py

@@ -1,9 +1,15 @@
 """Type definitions for scorebook evaluation framework."""
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Sequence, Type, Union
 
 from scorebook.eval_datasets import EvalDataset
+from scorebook.metrics.metric_base import MetricBase
+
+# Type alias for metrics parameter
+Metrics = Union[
+    str, "MetricBase", Type["MetricBase"], Sequence[Union[str, "MetricBase", Type["MetricBase"]]]
+]
 
 
 @dataclass
@@ -54,73 +60,37 @@ class ClassicEvalRunResult:
     run_spec: EvalRunSpec
     run_completed: bool
     outputs: Optional[List[Any]]
-    scores: Optional[Dict[str, Any]]
+    scores: Optional[Dict[str, List[Dict[str, Any]]]]  # score_async format
     run_id: Optional[str] = None
 
     @property
     def item_scores(self) -> List[Dict[str, Any]]:
         """Return a list of dictionaries containing scores for each evaluated item."""
-        results = []
-
-        if self.outputs:
-            for idx, output in enumerate(self.outputs):
-                if idx >= len(self.run_spec.inputs):
-                    break
-
-                result = {
-                    "id": idx,
-                    "dataset_name": self.run_spec.dataset.name,
-                    "input": self.run_spec.inputs[idx],
-                    "label": self.run_spec.labels[idx] if idx < len(self.run_spec.labels) else None,
-                    "output": output,
-                    **self.run_spec.hyperparameter_config,
-                }
-
-                # Add run_id if available
-                if self.run_id is not None:
-                    result["run_id"] = self.run_id
-
-                # Add individual item scores if available
-                if self.scores is not None:
-                    for metric_name, metric_data in self.scores.items():
-                        if isinstance(metric_data, dict) and "item_scores" in metric_data:
-                            if idx < len(metric_data["item_scores"]):
-                                result[metric_name] = metric_data["item_scores"][idx]
-                        else:
-                            # If scores is just a single value, replicate it for each item
-                            result[metric_name] = metric_data
-
-                results.append(result)
-
-        return results
+        if self.scores and "item_results" in self.scores:
+            # score_async already built this in the exact format we need
+            return self.scores["item_results"]
+        return []
 
     @property
     def aggregate_scores(self) -> Dict[str, Any]:
         """Return the aggregated scores for this run."""
-        result = {
+        if (
+            self.scores
+            and "aggregate_results" in self.scores
+            and len(self.scores["aggregate_results"]) > 0
+        ):
+            result = self.scores["aggregate_results"][0].copy()
+            # Add run_completed (not included in score_async format)
+            result["run_completed"] = self.run_completed
+            return result
+
+        # Fallback if no scores available
+        return {
             "dataset": self.run_spec.dataset.name,
             "run_completed": self.run_completed,
             **self.run_spec.hyperparameter_config,
         }
 
-        # Add run_id if available
-        if self.run_id is not None:
-            result["run_id"] = self.run_id
-
-        # Add aggregate scores from metrics
-        if self.scores is not None:
-            for metric_name, metric_data in self.scores.items():
-                if isinstance(metric_data, dict) and "aggregate_scores" in metric_data:
-                    # Flatten the aggregate scores from each metric
-                    for key, value in metric_data["aggregate_scores"].items():
-                        score_key = key if key == metric_name else f"{metric_name}_{key}"
-                        result[score_key] = value
-                else:
-                    # If scores is just a single value, use it as is
-                    result[metric_name] = metric_data
-
-        return result
-
 
 @dataclass
 class AdaptiveEvalRunResult:
@@ -180,3 +150,12 @@ class EvalResult:
             results.append(run_result.aggregate_scores)
 
         return results
+
+
+@dataclass
+class MetricScore:
+    """Container for metric scores across multiple runs."""
+
+    metric_name: str
+    aggregate_scores: Dict[str, Any]
+    item_scores: List[Dict[str, Any]]

scorebook/utils/__init__.py

@@ -1,16 +1,23 @@
 """Utility functions and common helpers for the Scorebook framework."""
 
+from contextlib import nullcontext
+
 from scorebook.utils.async_utils import async_nullcontext, is_awaitable
+from scorebook.utils.common_helpers import resolve_show_progress, resolve_upload_results
 from scorebook.utils.io_helpers import validate_path
-from scorebook.utils.progress_bars import evaluation_progress_context
+from scorebook.utils.progress_bars import evaluation_progress_context, scoring_progress_context
 from scorebook.utils.render_template import render_template
 from scorebook.utils.transform_helpers import expand_dict
 
 __all__ = [
     "async_nullcontext",
+    "nullcontext",
     "is_awaitable",
+    "resolve_show_progress",
+    "resolve_upload_results",
     "validate_path",
     "expand_dict",
     "evaluation_progress_context",
+    "scoring_progress_context",
     "render_template",
 ]

scorebook/utils/common_helpers.py

@@ -0,0 +1,41 @@
+"""Common helper functions shared across scorebook modules."""
+
+import logging
+from typing import Literal, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_upload_results(upload_results: Union[Literal["auto"], bool]) -> bool:
+    """Resolve the upload_results parameter based on trismik login status.
+
+    Args:
+        upload_results: Can be True, False, or "auto". When "auto", resolves to True
+            if user is logged in to Trismik, False otherwise.
+
+    Returns:
+        bool: Whether to upload results to Trismik
+    """
+    if upload_results == "auto":
+        from scorebook.trismik.credentials import get_token
+
+        upload_results = get_token() is not None
+        logger.debug("Auto upload results resolved to: %s", upload_results)
+
+    return upload_results
+
+
+def resolve_show_progress(show_progress: Optional[bool]) -> bool:
+    """Resolve whether to show progress bars.
+
+    Args:
+        show_progress: Explicit setting (None uses default from settings)
+
+    Returns:
+        bool: Whether to show progress bars
+    """
+    if show_progress is None:
+        from scorebook.settings import SHOW_PROGRESS_BARS
+
+        return bool(SHOW_PROGRESS_BARS)
+    return show_progress

scorebook/utils/progress_bars.py

@@ -787,3 +787,70 @@ def evaluation_progress_context(
         yield progress_bars
     finally:
         progress_bars.close_progress_bars()
+
+
+@contextmanager
+def scoring_progress_context(
+    total_metrics: int,
+    enabled: bool = True,
+) -> Generator[Optional[tqdm], None, None]:
+    """Context manager for scoring progress display.
+
+    Args:
+        total_metrics: Total number of metrics to score
+        enabled: Whether to show progress bar (default: True)
+
+    Yields:
+        Optional[tqdm]: Progress bar instance (None if disabled)
+    """
+    if not enabled:
+        yield None
+        return
+
+    # Use appropriate spinner frames based on environment
+    spinner_frames = SPINNER_FRAMES if SPINNER_FRAMES else ["|"]
+    spinner_cycle_obj = cycle(spinner_frames)
+
+    # Get initial spinner frame
+    initial_frame = next(spinner_cycle_obj)
+
+    progress_bar = tqdm(
+        total=total_metrics,
+        desc=f"{initial_frame} Scoring metrics",
+        unit="metric",
+        leave=False,
+        bar_format="{desc} | {n}/{total} metrics {percentage:3.0f}%|{bar}|",
+    )
+
+    # Start spinner animation thread
+    stop_event = threading.Event()
+    current_metric_name = [""]  # List to allow mutation in closure
+
+    def animate_spinner() -> None:
+        """Update spinner and description in background thread."""
+        while not stop_event.is_set():
+            try:
+                frame = next(spinner_cycle_obj)
+                metric_suffix = f": {current_metric_name[0]}" if current_metric_name[0] else ""
+                progress_bar.set_description_str(
+                    f"{frame} Scoring metrics{metric_suffix}", refresh=True
+                )
+                time.sleep(SPINNER_INTERVAL_SECONDS)
+            except Exception:
+                break
+
+    spinner_thread = threading.Thread(target=animate_spinner, daemon=True)
+    spinner_thread.start()
+
+    # Attach helper method to update current metric name
+    def set_current_metric(metric_name: str) -> None:
+        current_metric_name[0] = metric_name
+
+    progress_bar.set_current_metric = set_current_metric
+
+    try:
+        yield progress_bar
+    finally:
+        stop_event.set()
+        spinner_thread.join(timeout=1.0)
+        progress_bar.close()

{scorebook-0.0.11.dist-info → scorebook-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scorebook
-Version: 0.0.11
+Version: 0.0.12
 Summary: A Python project for LLM evaluation.
 License-File: LICENSE
 Author: Euan Campbell
@@ -37,7 +37,7 @@ Requires-Dist: torch ; extra == "examples"
 Requires-Dist: torchaudio ; extra == "examples"
 Requires-Dist: torchvision ; extra == "examples"
 Requires-Dist: transformers ; extra == "examples"
-Requires-Dist: trismik (>=1.0.1,<2.0.0)
+Requires-Dist: trismik (==1.0.1)
 Description-Content-Type: text/markdown
 
 # Scorebook

{scorebook-0.0.11.dist-info → scorebook-0.0.12.dist-info}/RECORD

@@ -1,4 +1,4 @@
-scorebook/__init__.py,sha256=uifumovUYn62n_VRFTeieEP3eVP8ycZ3lDp44sVwgeI,639
+scorebook/__init__.py,sha256=dcaqd4-qxLHPCw6p-LS_0b8JumEpHDtEilgwP8qNKRY,868
 scorebook/cli/__init__.py,sha256=E89jR1DljFSHhfjEGSRKLgz0KhxGyRQ9a3vpUOmQL9o,32
 scorebook/cli/auth.py,sha256=T6-5662Jh-HEhZvfUgy82BvxIiRzjZne-4LRp9Gb2JE,2937
 scorebook/cli/main.py,sha256=cEvShENl6L6feX_sa7FGNTeoz5UtwqzwenmcHaON1hg,1589
@@ -6,11 +6,11 @@ scorebook/eval_datasets/__init__.py,sha256=9YPjxjdaMaOrBUzJwvsUlFPl-KdYMgUGTV3WN
 scorebook/eval_datasets/eval_dataset.py,sha256=6GgrAaWelU5dK6I-x9zXHCxVSfvo41yyYNPF0ue4zbo,27200
 scorebook/evaluate/__init__.py,sha256=m3mCjeLildghT86ZDwY4GxCmaYZmhjbxkuTk0M9S_mc,423
 scorebook/evaluate/_async/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scorebook/evaluate/_async/evaluate_async.py,sha256=kcUrxfXdleqjn-Ajn06jGAfMvftmwQLzbB2zLu2-Q3U,16983
+scorebook/evaluate/_async/evaluate_async.py,sha256=qZ2y7-uQRT1b4saBoNaPO9fv4G2LhcP_ZyvkSsIEgHg,15629
 scorebook/evaluate/_sync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scorebook/evaluate/_sync/evaluate.py,sha256=qBOQZQYfpHSz4i_uRgH7QdZvhw0isOmIYPdqcLIWvwQ,16821
-scorebook/evaluate/evaluate_helpers.py,sha256=sSWWdyH5h1jJsQ_ABzRzgW0-Dy21BQ2PzdCJ0-uROC8,13829
-scorebook/exceptions.py,sha256=i494gw1TnSV-vS3RWGGZ6FYdlldjcY1qQuXO1htukuQ,3551
+scorebook/evaluate/_sync/evaluate.py,sha256=xanhHu-CaY_WarNM1V64W2sHttkM18j42K0MKrdtrvE,15438
+scorebook/evaluate/evaluate_helpers.py,sha256=swbgB1LurWdufeiVIZZ7ildsYO-ptC7uF3x6AVgptkU,13809
+scorebook/exceptions.py,sha256=3sxCWhFqYgXiWNUAMRR2ggLfqvbDI8e5vLjnT9V7X1M,3649
 scorebook/inference/__init__.py,sha256=u3TmfftO0oMkz8ngwxAKLPfL1so1w2hbK7c5UNlRq-M,345
 scorebook/inference/clients/__init__.py,sha256=QCjbrXYeFd7xK-5ZH7o7bSaKUJqHtGnH5285pezNKyY,242
 scorebook/inference/clients/bedrock.py,sha256=bsnz0IB6ufjZVPd6syD3yVaOelerB5G_YAmPAVqmBmI,10071
@@ -23,20 +23,28 @@ scorebook/metrics/accuracy.py,sha256=5KQ4hfOn9M94sB7WsXUelJWJiuKfoCGQEl5q5q9vNfo
 scorebook/metrics/metric_base.py,sha256=I3L0DGcRojFp93UGFnXG1tZ2UK9ilTcXXJG6lj5ddXA,857
 scorebook/metrics/metric_registry.py,sha256=jWwt9P3zvtFLlEYrd60v7LS7X251nZczouE02zcCxWg,3402
 scorebook/metrics/precision.py,sha256=AaYPYYKnY74Nwqp_p3jd2Ewf3VHNOJjoRWf5fhb-tXk,563
+scorebook/score/__init__.py,sha256=pwjSEb8Tc1edQpYDuu49wnupazISpRX3DQGD2cfiJek,208
+scorebook/score/_async/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scorebook/score/_async/score_async.py,sha256=GM84UcuFvW1x6ZIePEshG2cwVNB9GvwhhjouOduUwTA,6097
+scorebook/score/_sync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scorebook/score/_sync/score.py,sha256=rbJhYEhu8auHG4AwpZIkmzw_0ZK1bzbDiIK7Q0ApxhY,6043
+scorebook/score/score_helpers.py,sha256=lq0t5UrOgxa_pDiwL3yHbBlT2BL5B-SkWw1nyaXVoZU,7074
 scorebook/settings.py,sha256=qZrNiki6rFXn43udmhjQSmdDKOEaX62WYoEs2Rbggr0,720
 scorebook/trismik/__init__.py,sha256=kWZkEC57LJscRZNLE3sJR1L5w-ltb5mEbQd3_ePtZPQ,380
 scorebook/trismik/credentials.py,sha256=WtJLaNmBMwCi6gT1Bgp4J9x2tq5HDrDI9U074r08TnU,3275
-scorebook/types.py,sha256=8weXPYzUw9m4fy2O_TleqThg1OI4z_lQyx78brJigJU,5955
-scorebook/utils/__init__.py,sha256=IhL8bss1s-QkguwYp7T3jamk5GmsJRFjf9MynAN1W5g,544
+scorebook/trismik/upload_results.py,sha256=jgT9EVFpuv6OmrYgZVi032cbRrcCOyX4ulLDeWPFBWU,9743
+scorebook/types.py,sha256=x5bD2DU-Xafh7pXwmaQQ1i1zoZDsniHJjE-UEfXySAg,4827
+scorebook/utils/__init__.py,sha256=crefSaTUWkhFF-w4kotUzcz9_GGZukQDgRit4HxJRHY,805
 scorebook/utils/async_utils.py,sha256=2ewk_VOePib8z7DTRl-pZQBGzVI3L3JvnEuYW-DTkRA,1325
+scorebook/utils/common_helpers.py,sha256=jewPdQH4JqTWcYT31wn1WNucOPLtGbrGdViwwlYRhD4,1216
 scorebook/utils/io_helpers.py,sha256=ORO6DwtXOKWJq9v_isuunUrz0viE3xy2qYO4lrgU-TM,1437
 scorebook/utils/jinja_helpers.py,sha256=ksIKHiKdj8N0o7ZJZGasfbSNoAY6K5d9X_KM6mcKYD4,4208
 scorebook/utils/mappers.py,sha256=OcUnPBrnSUxZNhAzJhVmVWUWmqIKFXLTrK-xLi6_SUg,1259
-scorebook/utils/progress_bars.py,sha256=bkKZBSUt5kJi_ZyRhEE0UWrgB2NZpua7jxZ8xqsNyuk,29792
+scorebook/utils/progress_bars.py,sha256=gdT6dJ9LMLYzs7TospP3wQNY9htm_FhVLdX0ueluC6E,31890
 scorebook/utils/render_template.py,sha256=NOaZt-N1WcR5MA7at1XxzD-4sFMFKo9X0k7fKq6oSSM,1654
 scorebook/utils/transform_helpers.py,sha256=UnVLtFvcJrtmBEmLsuA4rrX4iJlNUKxm2DkIOGLl-2o,1030
-scorebook-0.0.11.dist-info/METADATA,sha256=FTV_4abv4NK1z9KbKx4sL8Qto74pMcHhCKZnskGWolo,11515
-scorebook-0.0.11.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-scorebook-0.0.11.dist-info/entry_points.txt,sha256=9gNd3Q0MEozhJ7fog-Q-Z_PrcGMnF-404Jon40MH2_U,53
-scorebook-0.0.11.dist-info/licenses/LICENSE,sha256=JLH1g9FhxHZf6CBCeQ_xAisPtICVObuNGW1bLPiTYEs,1068
-scorebook-0.0.11.dist-info/RECORD,,
+scorebook-0.0.12.dist-info/METADATA,sha256=bMjbT1e0GYExB1HcBkAfesaUcXK2-Pck5ox2oCUBXpE,11508
+scorebook-0.0.12.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+scorebook-0.0.12.dist-info/entry_points.txt,sha256=9gNd3Q0MEozhJ7fog-Q-Z_PrcGMnF-404Jon40MH2_U,53
+scorebook-0.0.12.dist-info/licenses/LICENSE,sha256=JLH1g9FhxHZf6CBCeQ_xAisPtICVObuNGW1bLPiTYEs,1068
+scorebook-0.0.12.dist-info/RECORD,,