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

scorebook/__init__.py

@@ -9,12 +9,15 @@ import importlib.metadata
 # get version from pyproject.toml
 __version__ = importlib.metadata.version(__package__ or __name__)
 
-from scorebook.eval_datasets import EvalDataset
-from scorebook.evaluate import evaluate, evaluate_async
+from scorebook.dashboard.create_project import create_project, create_project_async
+from scorebook.dashboard.credentials import login, logout, whoami
+from scorebook.dashboard.upload_results import upload_result, upload_result_async
+from scorebook.eval_datasets.eval_dataset import EvalDataset
+from scorebook.evaluate._async.evaluate_async import evaluate_async
+from scorebook.evaluate._sync.evaluate import evaluate
 from scorebook.inference.inference_pipeline import InferencePipeline
-from scorebook.score import score, score_async
-from scorebook.trismik.credentials import login, logout, whoami
-from scorebook.trismik.upload_results import upload_result, upload_result_async
+from scorebook.score._async.score_async import score_async
+from scorebook.score._sync.score import score
 from scorebook.utils.render_template import render_template
 
 __all__ = [
@@ -28,6 +31,8 @@ __all__ = [
     "logout",
     "whoami",
     "InferencePipeline",
+    "create_project",
+    "create_project_async",
     "upload_result",
     "upload_result_async",
 ]

scorebook/cli/auth.py

@@ -4,7 +4,7 @@ import argparse
 import getpass
 import sys
 
-from scorebook.trismik.credentials import get_stored_token, get_token_path, login, logout, whoami
+from scorebook.dashboard.credentials import get_stored_token, get_token_path, login, logout, whoami
 
 
 def auth_command(args: argparse.Namespace) -> int:

scorebook/dashboard/__init__.py

@@ -0,0 +1 @@
+"""Trismik authentication and API integration."""

scorebook/dashboard/create_project.py

@@ -0,0 +1,91 @@
+"""Create projects in Trismik's experimentation platform."""
+
+import logging
+from typing import Optional
+
+from trismik.types import TrismikProject
+
+from scorebook.evaluate.evaluate_helpers import (
+    create_trismik_async_client,
+    create_trismik_sync_client,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def create_project(
+    name: str,
+    team_id: Optional[str] = None,
+    description: Optional[str] = None,
+) -> TrismikProject:
+    """Create a new project in Trismik's experimentation platform (synchronous).
+
+    This function creates a new project that can be used to organize experiments
+    and evaluation runs in the Trismik platform.
+
+    Args:
+        name: Name of the project
+        team_id: Optional ID of the team to create the project in. If not provided,
+            the project will be created in the user's default team.
+        description: Optional description of the project
+
+    Returns:
+        TrismikProject: Created project object containing project details including
+            id, name, description, accountId, createdAt, and updatedAt fields
+
+    Raises:
+        TrismikValidationError: If the request fails validation
+        TrismikApiError: If the API request fails
+    """
+    # Create Trismik client
+    trismik_client = create_trismik_sync_client()
+
+    # Create project via Trismik API
+    project = trismik_client.create_project(
+        name=name,
+        team_id=team_id,
+        description=description,
+    )
+
+    logger.info(f"Project '{name}' created successfully with ID: {project.id}")
+
+    return project
+
+
+async def create_project_async(
+    name: str,
+    team_id: Optional[str] = None,
+    description: Optional[str] = None,
+) -> TrismikProject:
+    """Create a new project in Trismik's experimentation platform (asynchronous).
+
+    This function creates a new project that can be used to organize experiments
+    and evaluation runs in the Trismik platform.
+
+    Args:
+        name: Name of the project
+        team_id: Optional ID of the team to create the project in. If not provided,
+            the project will be created in the user's default team.
+        description: Optional description of the project
+
+    Returns:
+        TrismikProject: Created project object containing project details including
+            id, name, description, accountId, createdAt, and updatedAt fields
+
+    Raises:
+        TrismikValidationError: If the request fails validation
+        TrismikApiError: If the API request fails
+    """
+    # Create Trismik async client
+    trismik_client = create_trismik_async_client()
+
+    # Create project via Trismik API (async)
+    project = await trismik_client.create_project(
+        name=name,
+        team_id=team_id,
+        description=description,
+    )
+
+    logger.info(f"Project '{name}' created successfully with ID: {project.id}")
+
+    return project

scorebook/{trismik → dashboard}/credentials.py

@@ -5,6 +5,10 @@ import os
 import pathlib
 from typing import Optional
 
+from trismik import TrismikClient
+
+from scorebook.settings import TRISMIK_SERVICE_URL
+
 logger = logging.getLogger(__name__)
 
 
@@ -66,15 +70,26 @@ def get_token() -> Optional[str]:
 
 
 def validate_token(token: str) -> bool:
-    """Validate the token by making a test API call to trismik."""
-    # TODO: Implement actual API validation once you have an endpoint
-    # This would typically make a request to something like:
-    # response = requests.get("https://api.trismik.com/whoami",
-    #                        headers={"Authorization": f"Bearer {token}"})
-    # return response.status_code == 200
-
-    # For now, just check it's not empty
-    return bool(token and token.strip())
+    """Validate the token by making a test API call to trismik.
+
+    Args:
+        token: The API token to validate.
+
+    Returns:
+        bool: True if the token is valid, False otherwise.
+    """
+    if not token or not token.strip():
+        return False
+
+    try:
+        # Create a client with the token and verify it works
+        client = TrismikClient(service_url=TRISMIK_SERVICE_URL, api_key=token)
+        client.me()
+        client.close()
+        return True
+    except Exception as e:
+        logger.debug(f"Token validation failed: {e}")
+        return False
 
 
 def login(trismik_api_key: str) -> None:

scorebook/{trismik → dashboard}/upload_results.py

@@ -21,7 +21,7 @@ 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"}
+KNOWN_ITEM_FIELDS = {"id", "dataset", "input", "output", "label", "run_id"}
 
 
 def upload_result(

scorebook/eval_datasets/__init__.py

@@ -1,5 +1 @@
 """Dataset utilities for scorebook."""
-
-from scorebook.eval_datasets.eval_dataset import EvalDataset
-
-__all__ = ["EvalDataset"]

scorebook/eval_datasets/eval_dataset.py

@@ -18,8 +18,10 @@ from scorebook.exceptions import (
     DatasetSampleError,
     MissingFieldError,
 )
-from scorebook.metrics import MetricBase, MetricRegistry
-from scorebook.utils import render_template, validate_path
+from scorebook.metrics.metric_base import MetricBase
+from scorebook.metrics.metric_registry import MetricRegistry
+from scorebook.utils.io_helpers import validate_path
+from scorebook.utils.render_template import render_template
 
 
 class EvalDataset:
@@ -137,6 +139,24 @@ class EvalDataset:
             raise DatasetNotInitializedError("Dataset is not initialized")
         return list(map(str, self._hf_dataset.column_names))
 
+    @property
+    def split(self) -> Optional[str]:
+        """Return the split name of the underlying HuggingFace dataset, if available.
+
+        Returns:
+            The split name (e.g., "train", "test", "validation") if the dataset was loaded
+            from HuggingFace with a specific split. Returns None if the dataset was created
+            from a list, CSV, JSON, or loaded without a split specification.
+
+        Raises:
+            DatasetNotInitializedError: If the dataset is not initialized.
+        """
+        if self._hf_dataset is None:
+            raise DatasetNotInitializedError("Dataset is not initialized")
+
+        split = self._hf_dataset.split
+        return str(split) if split is not None else None
+
     def shuffle(self) -> None:
         """Randomly shuffle the dataset items."""
         if self._hf_dataset is None:

scorebook/evaluate/__init__.py

@@ -1,15 +1 @@
-"""
-Evaluation module for Scorebook.
-
-This module provides both synchronous and asynchronous evaluation functions.
-The async version serves as the source of truth, with the sync version
-automatically generated using unasync.
-"""
-
-# Import from async module
-from ._async.evaluate_async import evaluate_async
-
-# Import from generated sync module
-from ._sync.evaluate import evaluate
-
-__all__ = ["evaluate", "evaluate_async"]
+"""Evaluation module for Scorebook."""

scorebook/evaluate/_async/evaluate_async.py

@@ -6,7 +6,7 @@ from trismik import TrismikAsyncClient, TrismikClient
 from trismik.settings import evaluation_settings
 from trismik.types import TrismikRunMetadata
 
-from scorebook.eval_datasets import EvalDataset
+from scorebook.eval_datasets.eval_dataset import EvalDataset
 from scorebook.evaluate.evaluate_helpers import (
     build_eval_run_specs,
     create_trismik_async_client,
@@ -15,6 +15,7 @@ from scorebook.evaluate.evaluate_helpers import (
     make_trismik_inference,
     prepare_datasets,
     prepare_hyperparameter_configs,
+    resolve_adaptive_split,
     validate_parameters,
 )
 from scorebook.exceptions import InferenceError, ScoreBookError
@@ -27,12 +28,9 @@ from scorebook.types import (
     EvalResult,
     EvalRunSpec,
 )
-from scorebook.utils import (
-    async_nullcontext,
-    evaluation_progress_context,
-    resolve_show_progress,
-    resolve_upload_results,
-)
+from scorebook.utils.async_utils import async_nullcontext
+from scorebook.utils.common_helpers import resolve_show_progress, resolve_upload_results
+from scorebook.utils.progress_bars import evaluation_progress_context
 
 logger = logging.getLogger(__name__)
 
@@ -40,6 +38,7 @@ logger = logging.getLogger(__name__)
 async def evaluate_async(
     inference: Union[Callable, InferencePipeline],
     datasets: Union[str, EvalDataset, List[Union[str, EvalDataset]]],
+    split: Optional[str] = None,
     hyperparameters: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None,
     metadata: Optional[Dict[str, Any]] = None,
     experiment_id: Optional[str] = None,
@@ -58,6 +57,7 @@ async def evaluate_async(
     Args:
         inference: The inference callable to evaluate
         datasets: Dataset(s) to evaluate on
+        split: Split to use for evaluation (default: "validation")
         hyperparameters: Hyperparameter configuration(s) to evaluate with
         metadata: Optional metadata to attach to the evaluation
         experiment_id: Optional experiment identifier
@@ -82,7 +82,7 @@ async def evaluate_async(
     validate_parameters(locals(), evaluate_async)
 
     # Prepare datasets, hyperparameters, and eval run specs
-    datasets = prepare_datasets(datasets, sample_size)
+    datasets = prepare_datasets(datasets, split, sample_size)
     hyperparameter_configs = prepare_hyperparameter_configs(hyperparameters)
     eval_run_specs = sorted(
         build_eval_run_specs(datasets, hyperparameter_configs, experiment_id, project_id, metadata),
@@ -378,8 +378,24 @@ async def run_adaptive_evaluation(
     Returns:
         Results from the adaptive evaluation
     """
+    # Fetch available splits from Trismik
+    dataset_info = await trismik_client.get_dataset_info(adaptive_run_spec.dataset)
+    available_splits = dataset_info.splits if hasattr(dataset_info, "splits") else []
+
+    # Resolve the split to use (with fallback: user-specified -> validation -> test)
+    resolved_split = resolve_adaptive_split(
+        test_id=adaptive_run_spec.dataset,
+        user_specified_split=adaptive_run_spec.split,
+        available_splits=available_splits,
+    )
+
+    # Create inference function with bound hyperparameters
+    async def inference_with_hyperparams(items: Any) -> Any:
+        return await inference(items, **adaptive_run_spec.hyperparameter_config)
+
     trismik_results = await trismik_client.run(
         test_id=adaptive_run_spec.dataset,
+        split=resolved_split,
         project_id=project_id,
         experiment=experiment_id,
         run_metadata=TrismikRunMetadata(
@@ -387,7 +403,7 @@ async def run_adaptive_evaluation(
             test_configuration={},
             inference_setup={},
         ),
-        item_processor=make_trismik_inference(inference),
+        item_processor=make_trismik_inference(inference_with_hyperparams),
         return_dict=False,
     )
 

scorebook/evaluate/_sync/evaluate.py

@@ -5,7 +5,7 @@ from trismik import TrismikAsyncClient, TrismikClient
 from trismik.settings import evaluation_settings
 from trismik.types import TrismikRunMetadata
 
-from scorebook.eval_datasets import EvalDataset
+from scorebook.eval_datasets.eval_dataset import EvalDataset
 from scorebook.evaluate.evaluate_helpers import (
     build_eval_run_specs,
     create_trismik_sync_client,
@@ -14,6 +14,7 @@ from scorebook.evaluate.evaluate_helpers import (
     make_trismik_inference,
     prepare_datasets,
     prepare_hyperparameter_configs,
+    resolve_adaptive_split,
     validate_parameters,
 )
 from scorebook.exceptions import InferenceError, ScoreBookError
@@ -26,12 +27,9 @@ from scorebook.types import (
     EvalResult,
     EvalRunSpec,
 )
-from scorebook.utils import (
-    nullcontext,
-    evaluation_progress_context,
-    resolve_show_progress,
-    resolve_upload_results,
-)
+from contextlib import nullcontext
+from scorebook.utils.common_helpers import resolve_show_progress, resolve_upload_results
+from scorebook.utils.progress_bars import evaluation_progress_context
 
 logger = logging.getLogger(__name__)
 
@@ -39,6 +37,7 @@ logger = logging.getLogger(__name__)
 def evaluate(
     inference: Union[Callable, InferencePipeline],
     datasets: Union[str, EvalDataset, List[Union[str, EvalDataset]]],
+    split: Optional[str] = None,
     hyperparameters: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None,
     metadata: Optional[Dict[str, Any]] = None,
     experiment_id: Optional[str] = None,
@@ -57,6 +56,7 @@ def evaluate(
     Args:
         inference: The inference callable to evaluate
         datasets: Dataset(s) to evaluate on
+        split: Split to use for evaluation (default: "validation")
         hyperparameters: Hyperparameter configuration(s) to evaluate with
         metadata: Optional metadata to attach to the evaluation
         experiment_id: Optional experiment identifier
@@ -81,7 +81,7 @@ def evaluate(
     validate_parameters(locals(), evaluate)
 
     # Prepare datasets, hyperparameters, and eval run specs
-    datasets = prepare_datasets(datasets, sample_size)
+    datasets = prepare_datasets(datasets, split, sample_size)
     hyperparameter_configs = prepare_hyperparameter_configs(hyperparameters)
     eval_run_specs = sorted(
         build_eval_run_specs(datasets, hyperparameter_configs, experiment_id, project_id, metadata),
@@ -377,8 +377,24 @@ def run_adaptive_evaluation(
     Returns:
         Results from the adaptive evaluation
     """
+    # Fetch available splits from Trismik
+    dataset_info = trismik_client.get_dataset_info(adaptive_run_spec.dataset)
+    available_splits = dataset_info.splits if hasattr(dataset_info, "splits") else []
+
+    # Resolve the split to use (with fallback: user-specified -> validation -> test)
+    resolved_split = resolve_adaptive_split(
+        test_id=adaptive_run_spec.dataset,
+        user_specified_split=adaptive_run_spec.split,
+        available_splits=available_splits,
+    )
+
+    # Create inference function with bound hyperparameters
+    def inference_with_hyperparams(items: Any) -> Any:
+        return inference(items, **adaptive_run_spec.hyperparameter_config)
+
     trismik_results = trismik_client.run(
         test_id=adaptive_run_spec.dataset,
+        split=resolved_split,
         project_id=project_id,
         experiment=experiment_id,
         run_metadata=TrismikRunMetadata(
@@ -386,7 +402,7 @@ def run_adaptive_evaluation(
             test_configuration={},
             inference_setup={},
         ),
-        item_processor=make_trismik_inference(inference),
+        item_processor=make_trismik_inference(inference_with_hyperparams),
         return_dict=False,
     )
 

scorebook/evaluate/evaluate_helpers.py

@@ -9,7 +9,8 @@ from trismik._async.client import TrismikAsyncClient
 from trismik._sync.client import TrismikClient
 from trismik.types import TrismikMultipleChoiceTextItem
 
-from scorebook import EvalDataset
+from scorebook.dashboard.credentials import get_token
+from scorebook.eval_datasets.eval_dataset import EvalDataset
 from scorebook.exceptions import (
     DataMismatchError,
     MetricComputationError,
@@ -17,9 +18,9 @@ from scorebook.exceptions import (
     ScoreBookError,
 )
 from scorebook.settings import TRISMIK_SERVICE_URL
-from scorebook.trismik.credentials import get_token
 from scorebook.types import AdaptiveEvalDataset, AdaptiveEvalRunSpec, EvalResult, EvalRunSpec
-from scorebook.utils import expand_dict, is_awaitable
+from scorebook.utils.async_utils import is_awaitable
+from scorebook.utils.transform_helpers import expand_dict
 
 logger = logging.getLogger(__name__)
 
@@ -91,6 +92,7 @@ def validate_parameters(params: Dict[str, Any], caller: Callable[..., Any]) -> N
 
 def prepare_datasets(
     datasets: Union[str, EvalDataset, List[Union[str, EvalDataset]]],
+    split: Optional[str] = None,
     sample_size: Optional[int] = None,
 ) -> List[Union[EvalDataset, AdaptiveEvalDataset]]:
     """Prepare and separate input datasets into classic and adaptive evaluation datasets."""
@@ -104,6 +106,12 @@ def prepare_datasets(
 
         # Prepare classic datasets
         if isinstance(dataset, EvalDataset):
+            # Warn if dataset split differs from provided split parameter
+            if split is not None and dataset.split is not None and dataset.split != split:
+                logger.warning(
+                    f"Dataset '{dataset.name}' has split '{dataset.split}' but evaluate split "
+                    f"parameter is '{split}'. The dataset split will be used."
+                )
 
             if sample_size is not None:
                 dataset = dataset.sample(sample_size)
@@ -111,8 +119,17 @@ def prepare_datasets(
             datasets_out.append(dataset)
 
         # Prepare adaptive datasets
-        elif isinstance(dataset, str) and dataset.endswith(":adaptive"):
-            datasets_out.append(AdaptiveEvalDataset(dataset))
+        elif isinstance(dataset, str) and ":adaptive" in dataset:
+            # Parse adaptive dataset
+            parts = dataset.split(":")
+            if len(parts) != 2 or parts[1] != "adaptive":
+                raise ParameterValidationError(
+                    f"Invalid adaptive dataset format: '{dataset}'. "
+                    f"Use 'test_id:adaptive' format and specify split via the split parameter."
+                )
+
+            # Use the split parameter for all adaptive datasets
+            datasets_out.append(AdaptiveEvalDataset(name=dataset, split=split))
 
         # TODO: dataset name string registry
         elif isinstance(dataset, str):
@@ -174,6 +191,7 @@ def build_eval_run_specs(
                         hyperparameters_index,
                         experiment_id,
                         project_id,
+                        dataset.split,
                         metadata,
                     )
                 )
@@ -220,6 +238,7 @@ def build_adaptive_eval_run_spec(
     hyperparameter_config_index: int,
     experiment_id: str,
     project_id: str,
+    split: Optional[str] = None,
     metadata: Optional[Dict[str, Any]] = None,
 ) -> AdaptiveEvalRunSpec:
     """Build AdaptiveEvalRunSpec objects for a dataset/hyperparameter combination."""
@@ -231,6 +250,7 @@ def build_adaptive_eval_run_spec(
         hyperparameter_config_index,
         experiment_id,
         project_id,
+        split,
         metadata,
     )
     logger.debug("Built AdaptiveEvalRunSpec: %s", adaptive_eval_run_spec)
@@ -386,3 +406,57 @@ def make_trismik_inference(
         )
 
     return sync_trismik_inference_function
+
+
+def resolve_adaptive_split(
+    test_id: str,
+    user_specified_split: Optional[str],
+    available_splits: List[str],
+) -> str:
+    """Resolve the dataset split to use for adaptive evaluation.
+
+    Resolution order:
+    1. If user specified a split, validate it exists and use it
+    2. If not specified and exactly one split is available, use it
+    3. If not specified and multiple splits are available, raise an error
+    4. If no splits are available, raise an error
+
+    Args:
+        test_id: The test dataset ID (without ":adaptive" suffix)
+        user_specified_split: Optional split name specified by the user
+        available_splits: List of available split names for this dataset
+
+    Returns:
+        The resolved split name to use
+
+    Raises:
+        ScoreBookError: If the specified split doesn't exist, multiple splits exist without
+            user specification, or no splits are available
+    """
+    logger.debug(f"Available splits for {test_id}: {available_splits}")
+
+    # If user specified a split, validate and use it
+    if user_specified_split is not None:
+        if user_specified_split in available_splits:
+            logger.info(f"Using user-specified split '{user_specified_split}' for {test_id}")
+            return user_specified_split
+        else:
+            raise ScoreBookError(
+                f"Specified split '{user_specified_split}' not found for dataset '{test_id}'. "
+                f"Available splits: {available_splits}"
+            )
+
+    # No split specified - check available splits
+    if len(available_splits) == 0:
+        raise ScoreBookError(f"No splits available for dataset '{test_id}'. ")
+    elif len(available_splits) == 1:
+        # Exactly one split - auto-select it
+        selected_split = available_splits[0]
+        logger.info(f"Auto-selecting only available split '{selected_split}' for {test_id}")
+        return selected_split
+    else:
+        # Multiple splits available - user must specify
+        raise ScoreBookError(
+            f"Multiple splits available for dataset '{test_id}': {available_splits}. "
+            f"Please specify which split to use via evaluate's 'split' parameter."
+        )

scorebook/inference/__init__.py

@@ -1,11 +1 @@
-"""
-Inference module for model execution and predictions.
-
-This module provides functionality for running inference with various models
-and processing their responses. It includes utilities for both single and
-batch inference operations.
-"""
-
-from scorebook.inference.inference_pipeline import InferencePipeline
-
-__all__ = ["InferencePipeline"]
+"""Inference module for model execution and predictions."""

scorebook/inference/clients/__init__.py

@@ -1,8 +1 @@
-"""
-Inference clients for various LLM providers.
-
-This module provides client implementations for different LLM providers including
-OpenAI, AWS Bedrock, Google Vertex AI, and Portkey.
-"""
-
-__all__ = ["bedrock", "openai", "portkey", "vertex"]
+"""Inference clients for various LLM providers."""

scorebook/inference/inference_pipeline.py

@@ -9,7 +9,7 @@ configurable way.
 import asyncio
 from typing import Any, Callable, Dict, List, Optional, cast
 
-from scorebook.utils import is_awaitable
+from scorebook.utils.async_utils import is_awaitable
 
 
 class InferencePipeline:

scorebook/metrics/__init__.py

@@ -1,18 +1 @@
-"""
-Metrics for evaluating model predictions.
-
-This module provides a collection of evaluation metrics for comparing model outputs
-against ground truth labels. Available metrics include standard classification and
-generation metrics like accuracy, precision, recall, F1-score, etc.
-
-Metrics can be accessed by name through the `get_metrics()` function or used
-directly by instantiating specific metric classes. All metrics implement a
-common interface for scoring predictions against references.
-"""
-
-from scorebook.metrics.accuracy import Accuracy
-from scorebook.metrics.metric_base import MetricBase
-from scorebook.metrics.metric_registry import MetricRegistry
-from scorebook.metrics.precision import Precision
-
-__all__ = ["MetricBase", "Precision", "Accuracy", "MetricRegistry"]
+"""Metrics for evaluating model predictions."""

scorebook/metrics/metric_registry.py

@@ -85,8 +85,10 @@ class MetricRegistry:
         # If input is a string, look up the class in the registry
         if isinstance(name_or_class, str):
             key = name_or_class.lower()
+
             if key not in cls._registry:
                 raise ValueError(f"Metric '{name_or_class}' not registered.")
+
             return cls._registry[key](**kwargs)
 
         raise ValueError(

scorebook/score/__init__.py

@@ -1,6 +1 @@
 """Score module for computing metrics on pre-computed outputs."""
-
-from scorebook.score._async.score_async import score_async
-from scorebook.score._sync.score import score
-
-__all__ = ["score", "score_async"]

scorebook/score/_async/score_async.py

@@ -1,6 +1,7 @@
 import logging
 from typing import Any, Dict, List, Literal, Optional, Union, cast
 
+from scorebook.dashboard.upload_results import upload_result_async
 from scorebook.exceptions import DataMismatchError, ParameterValidationError
 from scorebook.score.score_helpers import (
     calculate_metric_scores_async,
@@ -8,9 +9,9 @@ from scorebook.score.score_helpers import (
     resolve_metrics,
     validate_items,
 )
-from scorebook.trismik.upload_results import upload_result_async
 from scorebook.types import Metrics
-from scorebook.utils import resolve_show_progress, resolve_upload_results, scoring_progress_context
+from scorebook.utils.common_helpers import resolve_show_progress, resolve_upload_results
+from scorebook.utils.progress_bars import scoring_progress_context
 
 logger = logging.getLogger(__name__)