Append new data to an existing EOPatch saved to disk about eo-learn HOT 6 CLOSED

class TemporalConcatenationTask(EOTask):
    """ Task to concatenate temporally a list of eopatches

    Only the DATA and MASK features are concatenated. The task assumes all patches contain the same features
    """
    def __init__(self, time_periods):
        """ Time periods will be sorted, assuming the 'YEAR/QX' format.

        :param time_periods: List of time periods to be concatenated, such as ['2018/Q4', '2019/Q1', '2019/Q2']
        :type time_periods: list of str
        :return: EOPatch with temporally concatenated arrays
        """
        self.time_periods = sorted(time_periods)
        self.time_indices = sorted(range(len(time_periods)), key=lambda k: time_periods[k])

    def execute(self, *eopatches):
        """ Sort patches temporally according to time_periods and concatenate starting from first """
        # sort list of eopatches according to provided time indices, e.g. eop_2019_q1, eop_2019_q2, eop_2019_q3
        eopatches = [eopatches[tidx] for tidx in self.time_indices]
        # get a list of timestamps of sorted eopatches. Timestamps are lists, so this is a list of lists
        timestamp_list = [eop.timestamp for eop in eopatches]
        # this mask finds dates in the next time period that are the same as the previous time period. The first
        # loop iterationloop will return (2019_q1_datetimes, 2019_q2_datetimes) and find the dates in 2019_q2 that match
        # the dates in 2019_q1. These will be ignored when concatenating 2019_q2
        masks = [np.isin(time_post, list(set(time_post).difference(set(time_pre))))
                 for time_pre, time_post in zip(timestamp_list[:-1], timestamp_list[1:])]
        # create concatenated timestamp by removing duplicated dates in trailing time periods
        timestamp = eopatches[0].timestamp + [tstamp for eop, mask in zip(eopatches[1:], masks)
                                              for tstamp, to_keep in zip(eop.timestamp, mask) if to_keep]
        # sort time periods in case the two sequences had a different time_difference
        sorted_indices = sorted(range(len(timestamp)), key=lambda k: timestamp[k])

        eop = EOPatch(bbox=eopatches[0].bbox, timestamp=sorted(timestamp))

        # TODO: add SCALAR
        # TODO: add check so that only features contained by all patches are concatenated
        for feature_type in [FeatureType.DATA, FeatureType.MASK]:
            for feature_name in eopatches[0][feature_type].keys():
                feat = (feature_type, feature_name)
                array = np.concatenate((eopatches[0][feat],
                                        *[eop[feat][mask] for eop, mask in zip(eopatches[1:], masks)]), axis=0)
                eop[feat] = array[sorted_indices]

        eop.meta_info['time_interval'] = (eop.timestamp[0].date().isoformat(),
                                          eop.timestamp[-1].date().isoformat())

        eop.meta_info['info'] = 'Temporally concatenated from {}'.format(' '.join(self.time_periods))

        return eop