def convert_to_serializable_data(data: Any, keep_list: bool = True) -> Any:
    """
    Recursively convert non-serializable objects to standard Python types.

    Handles numpy arrays and scalars, and torch tensors (if available).
    Recurses into dicts, lists, and tuples, preserving the original structure.

    Parameters
    ----------
    data : Any
        Data to convert.

    keep_list : bool, default=True
        Controls how single-element arrays and tensors are converted.

        - If `True` (default), arrays are always converted to lists, so a
          single-element array becomes a one-element list (e.g. `[42]`).
        - If `False`, single-element arrays and tensors are unwrapped to
          their scalar value (e.g. `42`).

    Returns
    -------
    Any
        The same structure with numpy/torch types replaced by standard Python types.

    Examples
    --------
    >>> import numpy as np
    >>> convert_to_serializable_data(np.array([1, 2, 3]))
    [1, 2, 3]

    >>> convert_to_serializable_data(np.array([42]))
    [42]

    >>> convert_to_serializable_data(np.array([42]), keep_list=False)
    42

    >>> convert_to_serializable_data(np.float32(3.14))
    3.14

    >>> convert_to_serializable_data({"a": np.array([1, 2]), "b": np.int64(7)})
    {'a': [1, 2], 'b': 7}

    >>> convert_to_serializable_data({"a": np.array([1, 2]), "b": np.int64(7)}, keep_list=False)
    {'a': [1, 2], 'b': 7}

    >>> convert_to_serializable_data(np.array([[1, 2], [3, 4]]), keep_list=False)
    [[1, 2], [3, 4]]
    """
    try:
        import torch
        if isinstance(data, torch.Tensor):
            result = data.detach().cpu().tolist()
            if not keep_list and data.numel() == 1:
                return result[0] if isinstance(result, list) else result
            return result
    except ImportError:
        pass

    if isinstance(data, np.ndarray):
        if not keep_list and data.size == 1:
            return data.flat[0].item()
        return data.tolist()

    if isinstance(data, np.generic):
        return data.item()

    if isinstance(data, dict):
        return {k: convert_to_serializable_data(v, keep_list=keep_list) for k, v in data.items()}

    if isinstance(data, (list, tuple)):
        converted = [convert_to_serializable_data(item, keep_list=keep_list) for item in data]
        return type(data)(converted)

    return data

def save_file(
        data: Any, 
        path: str, 
        append: bool = False,
        header: bool = False,
        index: bool = False,
    ) -> None:
    """
    Saves data to a file. The format is deduced from the file extension.

    Supported formats: `.json`, `.yaml` / `.yml`, `.csv`, `.npy`.

    Local paths are written directly to the filesystem. Paths beginning with
    `s3://` are written to an S3-compatible object store using the boto3
    utilities.

    Parameters
    ----------
    data : Any
        Data to be saved.
        - JSON / YAML: any JSON-serialisable object.
        - CSV: any object convertible to a `pandas.DataFrame` or a `pandas.DataFrame` itself.
        - NPY: a `numpy.ndarray`.
        - Images (`.png`, `.jpg`, `.jpeg`, `.bmp`, `.tiff`, `.webp`): a `PIL.Image.Image` or a `numpy.ndarray`.

    path : str
        Path to the output file, including extension.

        Examples:

        - `"./tmp.json"`
        - `"s3://my-bucket/data/file.json"`

    append : bool, default=False
        If `True`, extends the existing local file instead of overwriting it.

        This parameter is ignored for S3 paths, which are always overwritten.

        - **JSON / YAML list**: extends the list.
        - **JSON / YAML dict**: updates the dict.
        - **CSV**: appends rows (no header written).

    header : bool, default=False
        Only relevant for CSV files. If `True`, writes column names as the first row.
        When appending to an existing CSV file, the header is automatically
        disabled to avoid writing column names in the middle of the file.

    index : bool, default=False
        Only relevant for CSV files. Whether to write row indices.

    Examples
    --------
    >>> save_file({"a": 1}, "./tmp.json")
    >>> save_file([1, 2], "./tmp_list.json")
    >>> save_file({"b": 2}, "./tmp.json", append=True)
    >>> save_file({"x": 1}, "./tmp.yaml")
    >>> save_file([{"col": 1}], "./tmp.csv")

    >>> save_file(
    ...     {"a": 1},
    ...     "s3://my-bucket/data/file.json",
    ... )
    """

    ext = _get_extension(path)

    # Serialize data into bytes for S3 paths
    if path.startswith("s3://"):

        bucket, key = parse_s3_path(path)
        client = create_s3_client()

        serialized_data = _serialize_data(data, ext)

        write_s3_object(
            client=client,
            bucket=bucket,
            key=key,
            data=serialized_data,
        )

        return

    # Create parent directory
    parent = os.path.dirname(path)
    if parent:
        os.makedirs(parent, exist_ok=True)

    # Handle local JSON files
    if ext == ".json":

        if append and os.path.exists(path):

            with open(path, "r") as f:
                existing = json.load(f)

            if isinstance(existing, list) and isinstance(data, list):
                existing.extend(data)
                data = existing

            elif isinstance(existing, dict) and isinstance(data, dict):
                existing.update(data)
                data = existing

            else:
                logger.error(
                    "Cannot append: incompatible JSON types. "
                    f"Respectively: {type(existing)} and {type(data)}."
                )
                raise ValueError()

        with open(path, "w") as f:
            json.dump(data, f, indent=4)

    # Handle local YAML files
    elif ext in {".yaml", ".yml"}:

        if append and os.path.exists(path):
            with open(path, "r") as f:
                existing = yaml.safe_load(f)

            if isinstance(existing, list) and isinstance(data, list):
                existing.extend(data)
                data = existing

            elif isinstance(existing, dict) and isinstance(data, dict):
                existing.update(data)
                data = existing

            else:
                logger.error("Cannot append: incompatible YAML types.")
                raise RuntimeError()

        with open(path, "w") as f:
            yaml.safe_dump(data, f)

    # Handle local CSV files
    elif ext == ".csv":
        df = pd.DataFrame(data)
        if append and os.path.exists(path):
            df.to_csv(path, mode="a", header=False, index=index)
        else:
            df.to_csv(path, index=index, header=header)

    # Handle local NPY files
    elif ext == ".npy":
        np.save(path, data)

    # Handle local image files
    elif ext in _IMAGE_EXTENSIONS:
        if isinstance(data, np.ndarray):
            data = Image.fromarray(data)
        data.save(path)

def load_file(
        path: str,
        return_type: Optional[Literal["numpy", "pandas", "pil"]] = "pandas",
    ) -> Any:
    """
    Loads a file. The format is deduced from the file extension.

    Supported formats: `.json`, `.yaml` / `.yml`, `.csv`, `.npy`.

    Local paths are read directly from the filesystem. Paths beginning with
    `s3://` are read from an S3-compatible object store using the boto3
    utilities.

    Parameters
    ----------
    path : str
        Path to the file, including extension.

        Examples:

        - `"./tmp.json"`
        - `"s3://my-bucket/data/file.json"`

    return_type : Optional[Literal["numpy", "pandas", "pil"]], default="pandas"
        Controls the return type for CSV and image files.

        - CSV: `"pandas"` (default) returns a `pandas.DataFrame`; `"numpy"` returns a `numpy.ndarray`.
        - Images: `"pil"` (default for images) returns a `PIL.Image.Image`; `"numpy"` returns a `numpy.ndarray`.

    Returns
    -------
    Any
        Parsed file content.

    Examples
    --------
    >>> save_file({"a": 1}, "./tmp.json")
    >>> content = load_file("./tmp.json")
    >>> content["a"]
    1

    >>> save_file({"a": 1}, "./tmp.yaml")
    >>> content = load_file("./tmp.yaml")
    >>> content["a"]
    1

    >>> df = load_file("./tmp.csv")
    >>> arr = load_file("./tmp.csv", return_type="numpy")
    >>> content = load_file("s3://my-bucket/data/file.json")
    """

    # Read the file into a common file-like object
    if path.startswith("s3://"):

        bucket, key = parse_s3_path(path)
        client = create_s3_client()

        if file_exists(path) is False:
            logger.error(f"S3 object '{path}' does not exist.")
            raise FileNotFoundError()

        file_data = io.BytesIO(
            read_s3_object(
                client=client,
                bucket=bucket,
                key=key,
            )
        )

    else:

        if not os.path.exists(path):
            logger.error(f"File '{path}' does not exist.")
            raise FileNotFoundError()

        with open(path, "rb") as f:
            file_data = io.BytesIO(f.read())

    ext = _get_extension(path)

    # Parse the file according to its extension
    if ext == ".json":
        return json.load(file_data)

    elif ext in {".yaml", ".yml"}:
        return yaml.safe_load(file_data)

    elif ext == ".csv":

        df = pd.read_csv(file_data)

        if return_type == "numpy":
            return df.to_numpy()

        elif return_type == "pandas":
            return df

        else:
            logger.error(f"Unsupported return type: '{return_type}'. Supported: 'numpy', 'pandas'.")
            raise ValueError()

    elif ext == ".npy":
        return np.load(file_data, allow_pickle=False)

    elif ext in _IMAGE_EXTENSIONS:
        img = Image.open(file_data)
        img.load()
        if return_type == "numpy":
            return np.array(img)
        elif return_type == "pil":
            return img
        else:
            logger.error(f"Unsupported return type: '{return_type}'. Supported: 'numpy', 'pil'.")
            raise ValueError()

def file_exists(path: str) -> bool:
    """
    Checks if a file exists. Works for both local and S3 paths.

    Parameters
    ----------
    path : str
        Path to the file, including extension.

        Examples:

        - `"./tmp.json"`
        - `"s3://my-bucket/data/file.json"`

    Returns
    -------
    bool
        `True` if the file exists, `False` otherwise.

    Examples
    --------
    >>> save_file({"a": 1}, "./tmp.json")
    >>> file_exists("./tmp.json")
    True
    >>> file_exists("s3://my-bucket/data/file.json")
    False
    """

    if path.startswith("s3://"):
        bucket, key = parse_s3_path(path)
        client = create_s3_client()
        try:
            client.head_object(Bucket=bucket, Key=key)
            return True
        except ClientError as e:
            if e.response["Error"]["Code"] in ("404", "NoSuchKey"):
                return False
            raise

    else:
        return os.path.exists(path)