def METHOD_NAME(input_doc: ConsumableDocument) -> str:
    """
    Tries to collate pages from 2 single sided scans of a double sided
    document.
    When called with a file, it checks whether or not a staging file
    exists, if not, the current file is turned into that staging file
    containing the odd numbered pages.
    If a staging file exists, and it is not too old, the current file is
    considered to be the second part (the even numbered pages) and it will
    collate the pages of both, the pages of the second file will be added
    in reverse order, since the ADF will have scanned the pages from bottom
    to top.
    Returns a status message on succcess, or raises a ConsumerError
    in case of failure.
    """
    # Make sure scratch dir exists, Consumer might not have run yet
    settings.SCRATCH_DIR.mkdir(exist_ok=True)
    if input_doc.mime_type == "application/pdf":
        pdf_file = input_doc.original_file
    elif (
        input_doc.mime_type == "image/tiff"
        and settings.CONSUMER_COLLATE_DOUBLE_SIDED_TIFF_SUPPORT
    ):
        pdf_file = convert_from_tiff_to_pdf(
            input_doc.original_file,
            settings.SCRATCH_DIR,
        )
        input_doc.original_file.unlink()
    else:
        raise ConsumerError("Unsupported file type for collation of double-sided scans")
    staging = settings.SCRATCH_DIR / STAGING_FILE_NAME
    valid_staging_exists = False
    if staging.exists():
        stats = os.stat(str(staging))
        # if the file is older than the timeout, we don't consider
        # it valid
        if dt.datetime.now().timestamp() - stats.st_mtime > TIMEOUT_MINUTES * 60:
            logger.warning("Outdated double sided staging file exists, deleting it")
            os.unlink(str(staging))
        else:
            valid_staging_exists = True
    if valid_staging_exists:
        try:
            # Collate pages from second PDF in reverse order
            with Pdf.open(staging) as pdf1, Pdf.open(pdf_file) as pdf2:
                pdf2.pages.reverse()
                try:
                    for i, page in enumerate(pdf2.pages):
                        pdf1.pages.insert(2 * i + 1, page)
                except IndexError:
                    raise ConsumerError(
                        "This second file (even numbered pages) contains more "
                        "pages than the first/odd numbered one. This means the "
                        "two uploaded files don't belong to the same double-"
                        "sided scan. Please retry, starting with the odd "
                        "numbered pages again.",
                    )
                # Merged file has the same path, but without the
                # double-sided subdir. Therefore, it is also in the
                # consumption dir and will be picked up for processing
                old_file = input_doc.original_file
                new_file = Path(
                    *(
                        part
                        for part in old_file.with_name(
                            f"{old_file.stem}-collated.pdf",
                        ).parts
                        if part != settings.CONSUMER_COLLATE_DOUBLE_SIDED_SUBDIR_NAME
                    ),
                )
                # If the user didn't create the subdirs yet, do it for them
                new_file.parent.mkdir(parents=True, exist_ok=True)
                pdf1.save(new_file)
            logger.info("Collated documents into new file %s", new_file)
            return (
                "Success. Even numbered pages of double sided scan collated "
                "with odd pages"
            )
        finally:
            # Delete staging and recently uploaded file no matter what.
            # If any error occurs, the user needs to be able to restart
            # the process from scratch; after all, the staging file
            # with the odd numbered pages might be the culprit
            pdf_file.unlink()
            staging.unlink()
    else:
        shutil.move(pdf_file, staging)
        # update access to modification time so we know if the file
        # is outdated when another file gets uploaded
        os.utime(staging, (dt.datetime.now().timestamp(),) * 2)
        logger.info(
            "Got scan with odd numbered pages of double-sided scan, moved it to %s",
            staging,
        )
        return (
            "Received odd numbered pages of double sided scan, waiting up to "
            f"{TIMEOUT_MINUTES} minutes for even numbered pages"
        )