def METHOD_NAME(path):
    """Watches the path for new files and yields it once file is ready.
    Notes
    -----
    Currently, there is no proper way to know if the file has written
    entirely. So the workaround is we assume that files are generating
    serially (in most microscopes it common), and files are name in
    alphanumeric sequence We start loading the total number of minus the
    last file (`total__files - last`). In other words, once we see the new
    file in the directory, it means the file before it has completed so load
    that file. For this example, we also assume that the microscope is
    generating a `final.log` file at the end of the acquisition, this file
    is an indicator to stop monitoring the directory.
    Parameters
    ----------
    path : str
    directory to monitor and load tiffs as they start appearing.
    """
    current_files = set()
    processed_files = set()
    end_of_acquisition = False
    while not end_of_acquisition:
        files_to_process = set()
        # Get the all files in the directory at this time
        current_files = set(os.listdir(path))
        # Check if the end of acquisition has reached
        # if yes then remove it from the files_to_process set
        # and send it to display
        if end_of_experiment in current_files:
            files_to_process = current_files - processed_files
            files_to_process.remove(end_of_experiment)
            end_of_acquisition = True
        elif len(current_files):
            # get the last file from the current files based on the file names
            last_file = sorted(current_files, key=alphanumeric_key)[-1]
            current_files.remove(last_file)
            files_to_process = current_files - processed_files
        # yield every file to process as a dask.delayed function object.
        for p in sorted(files_to_process, key=alphanumeric_key):
            yield delayed(imread)(os.path.join(path, p))
        else:
            yield
        # add the files which we have yield to the processed list.
        processed_files.update(files_to_process)
        time.sleep(0.1)