pipeline

def add_algorithm(
    self,
    algorithm: type[Algorithm],
    params: dict[str, int] = {},
    algo_uuid: None | uuid.UUID = None,
) -> None:
    """Add algorithm to evaluate.

    Adding algorithm to evaluate on. The algorithm can be added by specifying the class type
    or by specifying the class name as a string.

    Args:
        algorithm: Algorithm to evaluate.
        params: Parameter for the algorithm.

    Raises:
        ValueError: If algorithm is not found in ALGORITHM_REGISTRY.
    """
    if not self._check_setting_exist():
        raise RuntimeError(
            "Setting has not been set. To ensure conformity, of the addition of"
            " other components please set the setting first. Call add_setting() method."
        )

    self.algo_state_mgr.register(algorithm_ptr=algorithm, params=params, algo_uuid=algo_uuid)

def build(self) -> EvaluatorPipeline:
    """Build Evaluator object.

    Raises:
        RuntimeError: If no metrics, algorithms or settings are specified.

    Returns:
        EvaluatorPipeline: The built evaluator object.
    """
    self._check_ready()
    return EvaluatorPipeline(
        algo_state_mgr=self.algo_state_mgr,
        metric_entries=list(self.metric_entries.values()),
        setting=self.setting,
        metric_k=self.metric_k,
        ignore_unknown_user=self.ignore_unknown_user,
        ignore_unknown_item=self.ignore_unknown_item,
        seed=self.seed,
    )

def set_metric_k(self, K: int) -> None:
    """Set K value for all metrics.

    Args:
        K: K value to set for all metrics.
    """
    self.metric_k = K

def add_metric(self, metric: str | type) -> None:
    """Add metric to evaluate algorithm on.

    Metric will be added to the metric_entries dict where it will later be
    converted to a list when the evaluator is constructed.

    Note:
        If K is not yet specified, the setting's top_K value will be used. This
        requires the setting to be set before adding the metric.

    Args:
        metric: Metric to evaluate algorithm on.

    Raises:
        ValueError: If metric is not found in METRIC_REGISTRY.
        RuntimeError: If setting is not set.
    """
    if not self._check_setting_exist():
        raise RuntimeError(
            "Setting has not been set. To ensure conformity, of the addition of"
            " other components please set the setting first. Call add_setting() method."
        )

    metric = arg_to_str(metric)

    if metric not in METRIC_REGISTRY:
        raise ValueError(f"Metric {metric} could not be resolved.")

    if not hasattr(self, "metric_k"):
        self.metric_k = self.setting.top_K
        warn(
            "K value not yet specified before setting metric, using setting's top_K value."
            " We recommend specifying K value for metric. If you want to change the K value,"
            " you can clear all metric entry and set the K value before adding metrics."
        )

    metric_name = f"{metric}_{self.metric_k}"
    if metric_name in self.metric_entries:
        logger.warning(f"Metric {metric_name} already exists. Skipping adding metric.")
        return

    self.metric_entries[metric_name] = MetricEntry(metric, self.metric_k)

def add_setting(self, setting: Setting) -> None:
    """Add setting to the evaluator builder.

    Note:
        The setting should be set before adding metrics or algorithms
        to the evaluator.

    Args:
        setting: Setting to evaluate the algorithms on.

    Raises:
        ValueError: If setting is not of instance Setting.
    """
    if not isinstance(setting, Setting):
        raise ValueError(f"setting should be of type Setting, got {type(setting)}")
    if hasattr(self, "setting") and self.setting is not None:
        warn("Setting is already set. Continuing will overwrite the setting.")

    self.setting = setting

def clear_metrics(self) -> None:
    """Clear all metrics from the builder."""
    self.metric_entries.clear()