def __init__(
    self,
    files: Iterable[str | Path] | Path | str,
    AI_file: str | Path | None = None,
    *,
    auto_load: bool = False,
    energy_resolution=20,
    **kwargs,
):
    # Update the process variables with any initial conditions
    self.process_vars = _new_process_vars(**kwargs)
    if energy_resolution not in self.process_vars:
        self.process_vars["energy_resolution"] = energy_resolution

    # Assert breaking behaviour on incorrect IO inputs
    self.files: list[Path] = []
    match files:
        case Path():
            # Check if it is a directory if so glob for .fits files
            if files.is_dir():
                path_list = list(files.rglob("**/**.fits"))
            else:
                from warnings import warn

                warn("A single file will not process correctly", stacklevel=2)
                path_list = [files]
        case list():
            path_list = [Path(file) for file in files]
        case _:
            raise TypeError(f"Invalid files input: {files}")
    try:
        re_name = name.infer_index_regex(
            [path.name for path in path_list], prefix_group="re_sample_name"
        )  # This will raise a valueerror if it won't work
        msg = f"\n Naming convention successfully identified: {re_name}\n"
        print(msg)
    except ValueError as ve:
        msg = "Files do not conform to any known naming convention.\n"
        msg += f"Error details: {ve}"
        raise ValueError(msg) from ve

    for fp in path_list:
        file: Path = Path(fp)
        if not file.is_file():
            raise FileNotFoundError(f"{file} is not a valid file.")
        if file.suffix != ".fits":
            raise ValueError(f"{file} is not a FITS file.")
        self.files.append(file)

    # Check AI File
    if isinstance(AI_file, (str, pathlib.Path)):
        print("Loading AI-file to supplement FITS meta-data")
        AI_file = pathlib.Path(AI_file)
        if not AI_file.is_file():
            msg = f"{AI_file} is not a valid file."
            raise FileNotFoundError(msg)
        if AI_file.suffix != ".txt":
            msg = f"{AI_file} is not valid for provided data"
            raise ValueError(msg)
    else:
        # Look for a companion AI file in the parent directory of the first file
        AI_file = (
            self.files[0].parent / f"{self.files[0].stem.split('-')[0]}-AI.txt"
        )
        AI_file = AI_file.resolve() if AI_file.exists() else None

    # Load the files into the Loader
    tmp = []
    # Get information about the sample / path from the first fits file
    path0 = self.files[0]
    self.path = path0.parent
    m = re.search(re_name, path0.name)
    self.name = m.group("re_sample_name") if m else "Unknown Sample"
    print("")
    print(f"Sample name identified as: {self.name}")
    print("")

    for file in tqdm(self.files, "Loading .fits", total=len(self.files)):
        # Collect information about the filepath to save --
        fits_name = file.name  # The name of the current file
        # fits_index = int(re.search(r'[ _-](\d+)\.fits$', fits_name).group(1))
        # Index of the file (if it gets messed up for some reason)
        # fits_index = extract_index(fits_name)
        m = re.search(re_name, fits_name)
        fits_index = int(m.group("index")) if m else -1
        # Load the data
        df_fits = dict_load_fits(file)  # Load .fits files into a dictionary
        if (
            AI_file is not None
        ):  # Only run if the meta-data needs to be reuplodaed from the .txt file
            temp_meta = self.load_AI_meta(file=AI_file)
            df_fits = self.update_meta(
                df_fits, temp_meta.iloc[fits_index]
            )  # get the correct line item in the AI file --
        df_fits["fits_index"] = fits_index  # Save the index
        tmp.append(df_fits)  # save the file
    data_dict = {key: [d[key] for d in tmp] for key in tmp[0]}
    df = pd.DataFrame(data_dict)
    # Rename the files and only extract those that matter--
    self.data: pd.DataFrame = (
        df[list(header_names.keys())]
        .rename(columns=header_names)
        .round(header_resolutions)
    )
    self.data["energy"] = (
        np.round(self.data["energy"] * self.process_vars["energy_resolution"])
        / self.process_vars["energy_resolution"]
    )  # round energy to the nearest 0.25 eV

    # Sort the files are if not in order of the file index
    self.data = self.data.sort_values("fits_index", ignore_index=True)
    self.data.insert(
        1, "scan", 0
    )  # populate a new volumn that identifies the individual scans

    # Other useful columns
    self.data["mask"] = None
    self.data["beam_spot"] = None

    # Has the data been processed?
    self.data_processed = False
    if auto_load:
        self.reprocess_images()