def append_experiments(previous_experiments, input_combinations):
    """Appends new experiments to previous experiments.

    Args:
        previous_experiments (dict): Dictionary of trials and their hyperparameters.
        input_combinations (list): List of input hyperparameter combinations.

    Returns:
        dict: Updated dictionary of trials and their hyperparameters.
    """
    all_combinations = input_combinations + [*previous_experiments.values()]
    trial_counter = len(previous_experiments) + 1
    unique_combinations = []
    for combo in all_combinations:
        if combo in unique_combinations:
            continue
        else:
            unique_combinations.append(combo)
    all_experiments = previous_experiments.copy()
    for combo in unique_combinations:
        if combo in previous_experiments.values():
            continue
        else:
            all_experiments[f"trial_{trial_counter}"] = combo
            trial_counter += 1
    return all_experiments

def get_trial_combinations(param_options):
    """Creates a cartesian product of all hyperparameter combinations based on input options.

    Args:
        param_options (dict): Tuning options for hyperparamters.

    Returns:
        list: List of hyperparameters combinations.
    """
    param_options_flat = flatten(param_options)
    params = list(param_options_flat.keys())
    options_cartesian = list(itertools.product(*[param_options_flat[param] for param in params]))
    trial_combinations = [unflatten(dict(zip(params, combo))) for combo in options_cartesian]
    return trial_combinations

def run_wfo(
    dataset_kwargs: dict[str, Any],
    hyperparameters: dict[tuple[str, ...], Any],
    trial: str,
    run_dir: str | Path,
    min_val_date: str | None = None,
    max_val_date: str | None = None,
    net_types: list[type[EconomicNetwork]] | None = None,
    epochs: int = int(2**10),
    parallel: int = 1,
    val_freq: Frequency = Frequency.quarter,
):
    """Runs wfo for a single trial.

    Args:
        dataset_kwargs (dict[str, Any]): Dataset related kwargs.
        encodings (dict[str, Any]): Encodings.
        hyperparameters (dict[tuple[str, ...], Any]): Updated hyperparameters for the trial.
        trial (str): Trial name.
        run_dir (str | Path): Trial directory.
        min_val_date (str | None, optional): Minimum validation week to include in periods. Defaults to None.
        max_val_date (str | None, optional): Maximum validaiton week to include in periods. Defaults to None.
        net_types (list[type[EconomicNetwork]] | None, optional): Networks. Defaults to None.
        epochs (int, optional): Epochs. Defaults to int(2**10).
        parallel (int, optional): Number of parallel jobs for wfo periods train and predict. Defaults to 1.
        val_freq (Frequencies, optional): Validation period frequency. Defaults to "quarter".

    Raises:
        RuntimeError: Raises if an exception occurs during wfo run or saving.
    """
    trial_id = int(trial.split("_")[-1])
    addons.use_loguru_logger(run_dir.parent / "wfo_log.log")
    logger.message_format = f" | {run_dir.name} | " + "{message}"
    setup_tensorflow_options(xla=False, debug=False)
    if net_types is None:
        net_types = DEFAULT_NETWORK_COMBINATION

    Network = make_multinet(net_types)

    tf.config.set_soft_device_placement(True)
    devices = tf.config.list_logical_devices("GPU")

    if len(devices) > 0:
        use_device = trial_id % len(devices)
        device = devices[use_device].name
    else:
        all_devices = tf.config.list_logical_devices()
        device = all_devices[0].name

    dataset, _ = make_dataset(**dataset_kwargs)
    model_builder = partial(build_model, hyperparameters=hyperparameters, net_combination=Network)
    with tf.device(device):
        wfo = WFORunner(
            dataset=dataset,
            model_builder=model_builder,
            val_freq=val_freq,
            min_val_date=min_val_date,
            max_val_date=max_val_date,
        )
        logger.info("WFO object created.")
        try:
            results = wfo.run(epochs=epochs, parallel=parallel, save_dir=run_dir, smoothing_window=True)
            calculated_metrics = wfo.calculate_metrics(
                results,
                weights="auto",
            )
            wfo.metrics_to_df(calculated_metrics).to_excel(run_dir / "metrics.xlsx")
            logger.info("WFO run completed and saved.")
        except Exception as e:
            logger.exception(exc=e, message="Exception occurred during wfo run.")
            raise RuntimeError("Exception occurred during wfo run") from e
        finally:
            del wfo
            logger.info("Model and wfo object deleted.")