# coding: utf8

"""

A module to extract patches in a slide.

Enable filtering on tissue surface ratio.

Draft for hierarchical patch extraction and representation is proposed.

"""

import warnings

import numpy

import openslide

from ..util.paths import slides_in_folder, slide_basename, safe_rmtree, get_files

from ..util.images import regular_grid, get_coords_from_mask

from ..util.basic import ifnone

from ..util.types import (

    Filter,

    FilterList,

    PathLike,

    NDImage,

    NDBoolMask,

    Coord,

    Patch,

    Slide,

)

from .visu import preview_from_queries

from .filters import (

    filter_hasdapi,

    filter_has_significant_dapi,

    filter_has_tissue_he,

    standardize_filters,

)

from .slide_filters import filter_thumbnail, filter_fluo_thumbnail

from .compat import convert_coords

import os

import csv

from skimage.io import imsave

from tqdm import tqdm

from .errors import UnknownFilterError, InvalidArgument

from typing import Optional, Sequence, Tuple, Iterator, Dict

from ..util.convert import (

    get_categorical_segments_from_edges,

    get_categorical_layer_edges,

    layer_segment_to_json_struct,

    gen_categorical_from_floatpreds,

    colorCycle,

)

import json

from fastcore.basics import listify

izi_filters = {

    "has-dapi": filter_hasdapi,

    "has-significant-dapi": filter_has_significant_dapi,

    "has-tissue-he": filter_has_tissue_he,

}

slide_filters = {"full": filter_thumbnail, "fluo": filter_fluo_thumbnail}

def filter_image(image: NDImage, filters: Sequence[Filter]) -> bool:

    """

    Check multiple filters on an image.

    Args:

        image: the patch to be filtered.

        filters: functions that turn images into booleans.

    Returns:

        Whether an image has passed every filters.

    """

    for filt in filters:

        if callable(filt):

            if not filt(image):

                return False

        elif type(filt) == str:

            if filt not in izi_filters:

                raise UnknownFilterError("{} is not a valid filter !!!".format(filt))

            if not izi_filters[filt](image):

                return False

        else:

            raise UnknownFilterError("{} is not a valid filter !!!".format(filt))

    return True

def apply_slide_filters(thumb: NDImage, filters: Sequence[Filter]) -> NDBoolMask:

    """

    Apply all filters to input thumbnail. Performs logical and between output masks.

    Args:

        thumb: thumbnail to compute mask from.

        filters: list of filters to apply to thumb. Each

            filter should output a boolean mask with same dimensions as thumb.

    Returns:

        Boolean mask where tissue pixels are True.

    """

    mask = numpy.ones(thumb.shape[:2], dtype=bool)

    for filt in filters:

        if isinstance(filt, str):

            if filt not in slide_filters:

                raise UnknownFilterError("{} is not a valid filter !!!".format(filt))

            filt = slide_filters[filt]

        mask = mask & filt(thumb)

    return mask

def slide_rois(

    slide: Slide,

    level: int,

    psize: Coord,

    interval: Coord = (0, 0),

    ancestors: Optional[Sequence[Patch]] = None,

    offset: Coord = (0, 0),

    filters: Optional[Sequence[Filter]] = None,

    thumb_size: int = 512,

    slide_filters: Optional[Sequence[Filter]] = None,

) -> Iterator[Tuple[Patch, NDImage]]:

    """

    Get patches with coordinates.

    Given a slide, a pyramid level, a patchsize in pixels, an interval in pixels

    and an offset in pixels, get patches with its coordinates.

    Args:

        slide: the slide to patchify.

        level: pyramid level.

        psize: (w, h) size of the patches (in pixels).

        interval: (x, y) interval between 2 neighboring patches.

        ancestors: patches that contain upcoming patches.

        offset: (x, y) offset in px on x and y axis for patch start.

        filters: filters to accept patches.

        thumb_size: size of thumbnail's longest side. Always preserves aspect ratio.

        slide_filters: list of filters to apply to thumbnail. Should output boolean mask.

    Yields:

        A tuple containing a Patch object and the corresponding image as

        ndarray.

    """

    psize = convert_coords(psize)

    offset = convert_coords(offset)

    ancestors = ifnone(ancestors, [])

    filters = listify(filters)

    slide_filters = listify(slide_filters)

    if len(ancestors) > 0:

        mag = slide.level_downsamples[level]

        shape = Coord(ancestors[0].size_0) / mag

        size_0 = psize * mag

        patches = []

        for ancestor in ancestors:

            # ancestor is a patch

            prefix = ancestor.id

            k = 0

            for patch_coord in regular_grid(shape, interval, psize):

                k += 1

                idx = "{}#{}".format(prefix, k)

                position = patch_coord * mag + ancestor.position

                patches.append(

                    Patch(

                        id=idx,

                        slidename=slide._filename.split("/")[-1],

                        position=position,

                        level=level,

                        size=psize,

                        size_0=size_0,

                        parent=ancestor,

                    )

                )

        for patch in tqdm(patches, ascii=True):

            try:

                image = slide.read_region(patch.position, patch.level, patch.size)

                image = numpy.array(image)[:, :, 0:3]

                if filter_image(image, filters):

                    yield patch, image

            except openslide.lowlevel.OpenSlideError:

                print(

                    "small failure while reading tile x={}, y={} in {}".format(

                        *patch.position, slide._filename

                    )

                )

    else:

        shape = Coord(*slide.level_dimensions[level])

        mag = slide.level_downsamples[level]

        thumb = numpy.array(slide.get_thumbnail((thumb_size, thumb_size)))

        mask = apply_slide_filters(thumb, slide_filters)

        k = 0

        for patch_coord in get_coords_from_mask(mask, shape, interval, psize):

            k += 1

            idx = "#{}".format(k)

            position = patch_coord * mag + offset

            size_0 = psize * mag

            try:

                image = slide.read_region(position, level, psize)

                image = numpy.array(image)[:, :, 0:3]

                if filter_image(image, filters):

                    yield Patch(

                        id=idx,

                        slidename=slide._filename.split("/")[-1],

                        position=position,

                        level=level,

                        size=psize,

                        size_0=size_0,

                    ), image

            except openslide.lowlevel.OpenSlideError:

                print(

                    "small failure while reading tile x={}, y={} in {}".format(

                        *position, slide._filename

                    )

                )

def slide_rois_no_image(

    slide: Slide,

    level: int,

    psize: Coord,

    interval: Coord = (0, 0),

    ancestors: Optional[Sequence[Patch]] = None,

    offset: Coord = (0, 0),

    thumb_size: int = 512,

    slide_filters: Optional[Sequence[Filter]] = None,

) -> Iterator[Patch]:

    """

    Get patches with coordinates.

    Given a slide, a pyramid level, a patchsize in pixels, an interval in pixels

    and an offset in pixels, get patches with its coordinates. Does not export image at

    any point.

    Args:

        slide: the slide to patchify.

        level: pyramid level.

        psize: (w, h) size of the patches (in pixels).

        interval: (x, y) interval between 2 neighboring patches.

        ancestors: patches that contain upcoming patches.

        offset: (x, y) offset in px on x and y axis for patch start.

        thumb_size: size of thumbnail's longest side. Always preserves aspect ratio.

        slide_filters: list of filters to apply to thumbnail. Should output boolean mask.

    Yields:

        A tuple containing a Patch object and the corresponding image as

        ndarray.

    """

    psize = convert_coords(psize)

    offset = convert_coords(offset)

    ancestors = ifnone(ancestors, [])

    slide_filters = listify(slide_filters)

    if len(ancestors) > 0:

        mag = slide.level_downsamples[level]

        shape = Coord(ancestors[0].size_0) / mag

        size_0 = psize * mag

        for ancestor in ancestors:

            # ancestor is a patch

            prefix = ancestor.id

            k = 0

            for patch_coord in regular_grid(shape, interval, psize):

                k += 1

                idx = "{}#{}".format(prefix, k)

                position = patch_coord * mag + ancestor.position

                yield Patch(

                    id=idx,

                    slidename=slide._filename.split("/")[-1],

                    position=position,

                    level=level,

                    size=psize,

                    size_0=size_0,

                    parent=ancestor,

                )

    else:

        shape = Coord(*slide.level_dimensions[level])

        mag = slide.level_downsamples[level]

        thumb = numpy.array(slide.get_thumbnail((thumb_size, thumb_size)))

        mask = apply_slide_filters(thumb, slide_filters)

        k = 0

        for patch_coord in get_coords_from_mask(mask, shape, interval, psize):

            k += 1

            idx = "#{}".format(k)

            position = patch_coord * mag + offset

            size_0 = psize * mag

            yield Patch(

                id=idx,

                slidename=slide._filename.split("/")[-1],

                position=position,

                level=level,

                size=psize,

                size_0=size_0,

            )

def patchify_slide(

    slidefile: PathLike,

    outdir: PathLike,

    level: int,

    psize: Coord,

    interval: Coord = (0, 0),

    offset: Coord = (0, 0),

    filters: Optional[Sequence[Filter]] = None,

    erase_tree: Optional[bool] = None,

    thumb_size: int = 512,

    slide_filters: Optional[Sequence[Filter]] = None,

    verbose: int = 2,

    silence: int = 0,

    backend: str = "openslide",

):

    """

    Save patches of a given wsi.

    Args:

        slidefile: abs path to slide file.

        outdir: abs path to an output folder.

        level: pyramid level.

        psize: (w, h) size of the patches (in pixels).

        interval: (x, y) interval between 2 neighboring patches.

        offset: (x, y) offset in px on x and y axis for patch start.

        filters: filters to accept patches.

        erase_tree: whether to erase outfolder if it exists. If None, user will be

            prompted for a choice.

        thumb_size: size of thumbnail's longest side. Always preserves aspect ratio.

        slide_filters: list of filters to apply to thumbnail. Should output boolean

            mask.

        verbose: 0 => nada, 1 => patchifying parameters, 2 => start-end of

            processes, thumbnail export.

        silence: 0 => write images, 1 => use images, but do not write, 2 => not even

            using images for filtering.

        backend: whether to use openslide or cucim as backend.

    """

    # Get name of the slide

    slide_id = slide_basename(slidefile)

    # if output directory has the same name, it's ok

    if os.path.basename(outdir) == slide_id:

        slide_folder_output = outdir

    # otherwise, create a subfolder with the name of the slide

    else:

        slide_folder_output = os.path.join(outdir, slide_id)

        if os.path.isdir(slide_folder_output):

            erase_tree = safe_rmtree(

                slide_folder_output, ignore_errors=True, erase_tree=erase_tree

            )

        os.makedirs(slide_folder_output, exist_ok=True)

    if verbose > 0:

        print("patchifying: {}".format(slidefile))

        if verbose > 1:

            print("level: {}".format(level))

            print("patch-size: {}".format(psize))

            print("interval: {}".format(interval))

            print("offset: {}".format(offset))

            print("filtering: {}".format(filters))

            print("starting patchification...")

    slide = Slide(slidefile, backend=backend)

    plist = []

    # level directory

    outleveldir = os.path.join(slide_folder_output, "level_{}".format(level))

    if os.path.isdir(outleveldir):

        safe_rmtree(outleveldir, ignore_errors=True, erase_tree=erase_tree)

    os.makedirs(outleveldir, exist_ok=True)

    ########################

    with warnings.catch_warnings():

        warnings.simplefilter("ignore")

        if silence == 0:

            # Write images

            for patch, img in slide_rois(

                slide,

                level,

                psize,

                interval,

                offset=offset,

                filters=filters,

                thumb_size=thumb_size,

                slide_filters=slide_filters,

            ):

                outfile = os.path.join(

                    outleveldir, "{}_{}_{}.png".format(*patch.position, patch.level)

                )

                imsave(outfile, img)

                plist.append(patch)

        elif silence == 1:

            # Do not write patches (but use images to filter)

            for patch, img in slide_rois(

                slide,

                level,

                psize,

                interval,

                offset=offset,

                filters=filters,

                thumb_size=thumb_size,

                slide_filters=slide_filters,

            ):

                plist.append(patch)

        elif silence == 2:

            # Do not write images and do not even use them to filter patches

            for patch in slide_rois_no_image(

                slide,

                level,

                psize,

                interval,

                offset=offset,

                thumb_size=thumb_size,

                slide_filters=slide_filters,

            ):

                plist.append(patch)

        else:

            raise InvalidArgument(

                "Invalid 'silence' parameter: '{}',"

                " should be one of [0, 1, 2]".format(silence)

            )

    if verbose > 1:

        print("end of patchification.")

        print("starting metadata csv export...")

    csv_columns = Patch.get_fields()

    csv_path = os.path.join(slide_folder_output, "patches.csv")

    with open(csv_path, "w") as csvfile:

        writer = csv.DictWriter(csvfile, csv_columns)

        writer.writeheader()

        writer.writerows(map(Patch.to_csv_row, plist))

    if verbose > 1:

        print("end of metadata export.")

        print("starting thumbnail export...")

        out_thumbnailfile = os.path.join(outleveldir, "thumbnail.png")

        thumbnail = preview_from_queries(slide, plist)

        imsave(out_thumbnailfile, thumbnail)

        print("ending thumbnail export.")

def patchify_slide_hierarchically(

    slidefile: PathLike,

    outdir: PathLike,

    top_level: int,

    low_level: int,

    psize: Coord,

    interval: Coord = (0, 0),

    offset: Coord = (0, 0),

    filters: Optional[FilterList] = None,

    silent: Optional[Sequence[int]] = None,

    erase_tree: Optional[bool] = None,

    thumb_size: int = 512,

    slide_filters: Optional[Sequence[Filter]] = None,

    verbose: int = 2,

    backend: str = "openslide",

):

    """

    Save patches of a given wsi in a hierarchical way.

    Args:

        slidefile: abs path to a slide file.

        outdir: abs path to an output folder.

        top_level: top pyramid level to consider.

        low_level: lowest pyramid level to consider.

        psize: (w, h) size of the patches (in pixels).

        interval: (x, y) interval between 2 neighboring patches.

        offset: (x, y) offset in px on x and y axis for patch start.

        filters: filters to accept patches.

        silent: pyramid level not to output.

        erase_tree: whether to erase outfolder if it exists. If None, user will be

            prompted for a choice.

        thumb_size: size of thumbnail's longest side. Always preserves aspect ratio.

        slide_filters: list of filters to apply to thumbnail. Should output boolean

            mask.

        verbose: 0 => nada, 1 => patchifying parameters, 2 => start-end of processes,

            thumbnail export.

        backend: whether to use openslide or cucim as backend.

    """

    filters = ifnone(filters, {})

    silent = ifnone(silent, [])

    level_filters = standardize_filters(filters, top_level, low_level)

    # Get name of the slide

    slide_id = slide_basename(slidefile)

    # if output directory has the same name, it's ok

    if os.path.basename(outdir) == slide_id:

        slide_folder_output = outdir

    # otherwise, create a subfolder with the name of the slide

    else:

        slide_folder_output = os.path.join(outdir, slide_id)

        if os.path.isdir(slide_folder_output):

            erase_tree = safe_rmtree(

                slide_folder_output, ignore_errors=True, erase_tree=erase_tree

            )

        os.makedirs(slide_folder_output, exist_ok=True)

    csv_columns = Patch.get_fields()

    csv_path = os.path.join(slide_folder_output, "patches.csv")

    slide = Slide(slidefile, backend=backend)

    with open(csv_path, "w") as csvfile:

        writer = csv.DictWriter(csvfile, csv_columns)

        writer.writeheader()

        plist = []

        current_plist = []

        for level in range(top_level, low_level - 1, -1):

            if verbose > 0:

                print("patchifying: {}".format(slidefile))

                if verbose > 1:

                    print("level: {}".format(level))

                    print("patch-size: {}".format(psize))

                    print("interval: {}".format(interval))

                    print("offset: {}".format(offset))

                    print("filtering: {}".format(level_filters[level]))

                    print("ancestors: {} patches".format(len(plist)))

                    print("starting patchification...")

            current_plist = []

            # level directory

            outleveldir = os.path.join(slide_folder_output, "level_{}".format(level))

            if os.path.isdir(outleveldir):

                safe_rmtree(outleveldir, ignore_errors=True, erase_tree=erase_tree)

            os.makedirs(outleveldir, exist_ok=True)

            ########################

            with warnings.catch_warnings():

                warnings.simplefilter("ignore")

                for patch, img in slide_rois(

                    slide,

                    level,

                    psize,

                    interval,

                    ancestors=plist,

                    offset=offset,

                    filters=level_filters[level],

                    thumb_size=thumb_size,

                    slide_filters=slide_filters,

                ):

                    if level not in silent:

                        outfile = os.path.join(

                            outleveldir,

                            "{}_{}_{}.png".format(*patch.position, patch.level),

                        )

                        imsave(outfile, img)

                    current_plist.append(patch)

            plist = [p for p in current_plist]

            if verbose > 1:

                print("end of patchification.")

                print("starting metadata csv export...")

            writer.writerows(map(Patch.to_csv_row, plist))

            if verbose > 1:

                print("end of metadata export.")

                print("starting thumbnail export...")

                out_thumbnailfile = os.path.join(outleveldir, "thumbnail.png")

                thumbnail = preview_from_queries(slide, current_plist)

                imsave(out_thumbnailfile, thumbnail)

                print("ending thumbnail export.")

def patchify_folder(

    infolder: str,

    outfolder: str,

    level: int,

    psize: Coord,

    interval: Coord = (0, 0),

    offset: Coord = (0, 0),

    filters: Optional[Sequence[Filter]] = None,

    extensions: Sequence[str] = (".mrxs",),

    recurse: bool = False,

    folders: Optional[Sequence[str]] = None,

    erase_tree: Optional[bool] = None,

    thumb_size: int = 512,

    slide_filters: Optional[Sequence[Filter]] = None,

    verbose: int = 2,

    silence: int = 0,

    backend: str = "openslide",

):

    """

    Save patches of all wsi inside a folder.

    Args:

        infolder: abs path to a folder of slides.

        outfolder: abs path to an output folder.

        level: pyramid level.

        psize: (w, h) size of the patches (in pixels).

        interval: (x, y) interval between 2 neighboring patches.

        offset: (x, y) offset in px on x and y axis for patch start.

        filters: filters to accept patches.

        extensions: list of file extensions to consider. Defaults to '.mrxs'.

        recurse: whether to look for files recursively.

        folders: list of subfolders to explore when recurse is True. Defaults to all.

        erase_tree: whether to erase outfolder if it exists. If None, user will be

            prompted for a choice.

        thumb_size: size of thumbnail's longest side. Always preserves aspect ratio.

        slide_filters: list of filters to apply to thumbnail. Should output boolean

            mask.

        verbose: 0 => nada, 1 => patchifying parameters, 2 => start-end of processes,

            thumbnail export.

        silence: 0 => write images, 1 => use images, but do not write, 2 => not even

            using images for filtering.

        backend: whether to use openslide or cucim as backend.

    """

    if os.path.isdir(outfolder):

        erase_tree = safe_rmtree(outfolder, ignore_errors=True, erase_tree=erase_tree)

    slidefiles = get_files(

        infolder, extensions=extensions, recurse=recurse, folders=folders

    ).map(str)

    slidefiles = slides_in_folder(infolder)

    total = len(slidefiles)

    k = 0

    for slidefile in slidefiles:

        k += 1

        if verbose > 0:

            print("slide {} / {}".format(k, total))

        slidename = slide_basename(slidefile)

        outdir = os.path.join(outfolder, slidename)

        if os.path.isdir(outdir):

            safe_rmtree(outdir, ignore_errors=True, erase_tree=erase_tree)

        os.makedirs(outdir, exist_ok=True)

        # patchify folder must be robust to 'missing image data' rare cases...

        try:

            patchify_slide(

                slidefile,

                outdir,

                level,

                psize,

                interval,

                offset=offset,

                filters=filters,

                erase_tree=erase_tree,

                thumb_size=thumb_size,

                slide_filters=slide_filters,

                verbose=verbose,

                silence=silence,

                backend=backend,

            )

        except (

            openslide.OpenSlideUnsupportedFormatError,

            openslide.lowlevel.OpenSlideError,

        ) as e:

            warnings.warn(str(e))

def patchify_folder_hierarchically(

    infolder: PathLike,

    outfolder: PathLike,

    top_level: int,

    low_level: int,

    psize: Coord,

    interval: Coord = (0, 0),

    offset: Coord = (0, 0),

    filters: Optional[FilterList] = None,

    silent: Optional[Sequence[int]] = None,

    extensions: Sequence[str] = (".mrxs",),

    recurse: bool = False,

    folders: Optional[Sequence[str]] = None,

    erase_tree: Optional[bool] = None,

    thumb_size: int = 512,

    slide_filters: Optional[Sequence[Filter]] = None,

    verbose: int = 2,

    backend: str = "openslide",

):

    """

    Save hierarchical patches of all wsi inside a folder.

    Args:

        infolder: abs path to a folder of slides.

        outfolder: abs path to an output folder.

        top_level: top pyramid level to consider.

        low_level: lowest pyramid level to consider.

        psize: (w, h) size of the patches (in pixels).

        interval: (x, y) interval between 2 neighboring patches.

        offset: (x, y) offset in px on x and y axis for patch start.

        filters: filters to accept patches.

        silent: pyramid level not to output.

        extensions: list of file extensions to consider. Defaults to '.mrxs'.

        recurse: whether to look for files recursively.

        folders: list of subfolders to explore when recurse is True. Defaults to all.

        erase_tree: whether to erase outfolder if it exists. If None, user will be

            prompted for a choice.

        verbose: 0 => nada, 1 => patchifying parameters, 2 => start-end of processes,

            thumbnail export.

        backend: whether to use openslide or cucim as backend.

    """

    if os.path.isdir(outfolder):

        erase_tree = safe_rmtree(outfolder, ignore_errors=True, erase_tree=erase_tree)

    slidefiles = get_files(

        infolder, extensions=extensions, recurse=recurse, folders=folders

    ).map(str)

    total = len(slidefiles)

    k = 0

    for slidefile in slidefiles:

        k += 1

        if verbose > 0:

            print("slide {} / {}".format(k, total))

        slidename = slide_basename(slidefile)

        outdir = os.path.join(outfolder, slidename)

        if os.path.isdir(outdir):

            safe_rmtree(outdir, ignore_errors=True, erase_tree=erase_tree)

        os.makedirs(outdir, exist_ok=True)

        try:

            patchify_slide_hierarchically(

                slidefile,

                outdir,

                top_level,

                low_level,

                psize,

                interval,

                offset=offset,

                filters=filters,

                silent=silent,

                erase_tree=erase_tree,

                thumb_size=thumb_size,

                slide_filters=slide_filters,

                verbose=verbose,

                backend=backend,

            )

        except (

            openslide.OpenSlideUnsupportedFormatError,

            openslide.lowlevel.OpenSlideError,

        ) as e:

            warnings.warn(str(e))

def export_floatpred_to_categorical_micromap_json(

    pathaiafolder: PathLike,

    slidefolder: PathLike,

    jsonfolder: PathLike,

    level: int,

    task: str,

    thresholds: Dict[int, Tuple[float, float]],

    classnames: Dict[int, str],

    extensions: Sequence[str] = (".mrxs",),

    recurse: bool = True,

):

    """

    Export pathaia csv to a json annotation file compatible with MicroMap.

    For each predicted category, a layer is created and connected components

    are computed.

    Args:

        infolder: abs path to a folder of pathaia csv.

        slidefolder: abs path to a folder of slides.

        jsonfolder: abs path to a folder of json annotations.

        level: level of patches to export.

        task: prediction task to export (csv column).

        thresholds: histogram bins for each category.

        classnames: class names for each category.

        extensions: slide extension.

    """

    color_dict = {k: colorCycle[k] for k in classnames}

    slidefiles = get_files(slidefolder, extensions=extensions, recurse=recurse).map(str)

    for slidefile in tqdm(slidefiles):

        slidename, _ = os.path.splitext(os.path.basename(slidefile))

        slidedir = os.path.dirname(slidefile)

        pathaia_slidedir = slidedir.replace(slidefolder, pathaiafolder)

        pathaiacsv = os.path.join(pathaia_slidedir, slidename, "patches.csv")

        json_slidedir = slidedir.replace(slidefolder, jsonfolder)

        pathaiajson = os.path.join(json_slidedir, "{}.json".format(slidename))

        try:

            slide = openslide.OpenSlide(slidefile)

            # print(f'Saving to json {pathaiajson} from {pathaiacsv}')

            gen = gen_categorical_from_floatpreds(pathaiacsv, level, task, thresholds)

            layer_edges, layer_meta, interval = get_categorical_layer_edges(

                gen, color_dict, classnames

            )

            layer_segments = get_categorical_segments_from_edges(layer_edges)

            annotations = layer_segment_to_json_struct(

                interval, layer_segments, layer_meta, slide

            )

            with open(pathaiajson, "w") as f:

                json.dump(annotations, f)

        except Exception as e:

            warnings.warn(

                "slide '{}'"

                " with patch file '{}'"

                " failed with error: '{}'".format(slidefile, pathaiacsv, str(e))

            )