def save_results_to_files(
    base_dir: Path,
    filename_pattern: str,
    result: GenerationResult,
    variables_names: Optional[Sequence[str]] = None,
    descriptor_names: Optional[Sequence[str]] = None,
    lazily: bool = False,
    only_instances: bool = False,
    files_format: Literal["csv", "parquet"] = "parquet",
):
    """Saves the results of the generation to CSV files.
    Args:
        filename_pattern (str): Pattern for the filenames.
        result (GenResult): Result of the generation.
        variables_names (Sequence[str]): Names of the variables.
        lazily (bool, optional): Whether the instances inside the result object
            should be collected as a LazyFrame or a DataFrame. Defaults ot False.
        only_instances (bool): Generate only the files with the resulting instances.
            Default True. If False, it would generate an history and arhice_metrics files.
        files_format (Literal[str] = "csv", "parquet"): Format to store the resulting instances file. Parquet is the most efficient for large datasets.
    """
    if files_format not in ("csv", "parquet"):
        warnings.warn(
            f"Unrecognised file format: {files_format}. Selecting parquet as fallback.",
            category=RuntimeWarning,
            stacklevel=2,
        )
        files_format = "parquet"
    _saving_fn = __saving_methods[files_format]
    if len(result.instances) != 0:
        frames = pl.concat(
            [
                instance.to_df(
                    variables_names=variables_names,
                    descriptor_names=descriptor_names,
                    portfolio_names=result.solvers,
                    lazy=lazily,
                )
                for instance in result.instances
            ],
            how="vertical_relaxed",
        )
        _saving_fn(
            frames=frames,
            base_dir=base_dir,
            filename_pattern=filename_pattern,
            lazily=lazily,
        )

        if not only_instances:
            result.history.to_df().write_csv(
                base_dir / f"{filename_pattern}_history.csv"
            )
            if result.metrics is not None:
                result.metrics.write_csv(
                    base_dir / f"{filename_pattern}_archive_metrics.csv"
                )
    else:
        warnings.warn(
            "Archive in Generation result is empty. Nothing to do in save_results_to_files.",
            category=RuntimeWarning,
            stacklevel=2,
        )

def sort_knapsack_instances(
    instances: np.ndarray | Sequence[Instance] | Archive | CVTArchive | GridArchive,
) -> np.ndarray | List[Instance]:
    """Sorts a collection of Knapsack Instances Genotypes based on lexicograph order by (w_i, p_i)

    Args:
        instances (np.ndarray | Sequence[Instance]): Instances to sort

    Raises:
        ValueError: If the dimension of the genotypes (minus Q) is not even. Note that KP instances should contain N pairs of values plus the capacity.

    Returns:
        np.ndarray | Sequence[Instance]: Sorted instances
    """
    genotypes = np.empty(0)
    if isinstance(instances, np.ndarray) and (instances.shape[1] - 1) % 2 != 0:
        raise ValueError(
            f"Something is wrong with these KP instances. Shape 1 should be even and got {instances.shape[1]}"
        )
    elif dimension := (len(instances[0]) - 1) % 2 != 0:
        raise ValueError(
            f"Something is wrong with these KP instances. Shape 1 should be even and got {dimension}"
        )

    genotypes = np.asarray(instances, copy=True)
    M, N = genotypes.shape

    pairs = genotypes[:, 1:].reshape(M, -1, 2)
    order = np.lexsort((pairs[:, :, 1], pairs[:, :, 0]), axis=1)
    sorted_pairs = np.take_along_axis(pairs, order[:, :, None], axis=1)
    genotypes[:, 1:] = sorted_pairs.reshape(M, -1)

    if isinstance(instances, np.ndarray):
        return genotypes
    else:
        return [
            instances[i].clone_with(variables=genotypes[i])
            for i in range(len(instances))
        ]