class ByPassPreparer(DataPreparer):
    """ByPass class, it fills the DataPreparer blank, but does nothing."""

    name = "no_preparer"

    def __init__(self, channels_last: bool = False) -> None:
        super().__init__()

        self.channels_last = channels_last
        self.collapsible_shapes = None
        self.dtype = None

    def prepare_input_data(self, data: np.ndarray) -> np.ndarray:
        """Prepare input data.

        Args:
            data (np.ndarray):

        Returns:
            numpy.ndarray:
        Example:

            >>> import numpy as np
            >>> data = np.random.rand(5, 3, 4, 2)
            >>> preparer = ByPassPreparer()
            >>> prepared_data = preparer.prepare_input_data(data)
            >>> prepared_data.shape
            (5, 3, 4, 2)
        """
        self.collapsible_shapes = data.shape[1:]
        return data

    def prepare_output_data(self, data: np.ndarray) -> np.ndarray:
        """Prepare output data.

        Args:
            data (np.ndarray):

        Returns:
            numpy.ndarray: The output data in the original format

        Example:

            >>> import numpy as np
            >>> data = np.random.rand(5, 3)
            >>> preparer = ByPassPreparer()
            >>> prepared_data = preparer.prepare_output_data(data)
            >>> prepared_data.shape
            (5, 3)
        """

        return data

    def prepare_input_structured_data(self, data: np.recarray) -> np.ndarray:
        """Prepare structured input data by converting it to an ndarray.

        Args:
            data (np.recarray):

        Returns:
            np.ndarray: numpy ndarray version of the input data.

        Note:
            This function is used when the input data is in the form of a structured array and needs to be converted to a regular numpy ndarray.
        Example:

            >>> import numpy as np
            >>> data = np.array([(1, 'a', 0.5), (2, 'b', 0.6)], dtype=[('a', int), ('b', '|S1'), ('c', float)])
            >>> preparer = ByPassPreparer()
            >>> preparer.prepare_input_structured_data(data)
            array([[1, 'a', 0.5],
                   [2, 'b', 0.6]])
        """

        return data

    def prepare_output_structured_data(self, data: np.ndarray) -> np.recarray:
        """Prepare structured output data by converting it to a recarray.

        Args:
            data (np.ndarray):

        Returns:
            np.recarray: numpy recarray version of the output data.

        Note:
            This function is used when the output data needs to be in the form of a structured array and is currently in the form of a regular numpy ndarray.
        Example:

            >>> import numpy as np
            >>> data = np.array([[1, 'a', 0.5], [2, 'b', 0.6]])
            >>> preparer = ByPassPreparer()
            >>> preparer.prepare_output_structured_data(data)
            rec.array([(1, 'a', 0.5), (2, 'b', 0.6)],
            dtype=[('f0', '<i4'), ('f1', 'S1'), ('f2', '<f8')])
        """
        return data

class Reshaper(DataPreparer):
    """Reshaper converts n-dimensional arrays to two-dimensional ones, performing a simple reshaping operation F: (n0, n1, ..., nm) -> (n0, prod(n1, ..., nm))"""

    name = "reshaper"

    def __init__(self, channels_last: bool = False) -> None:
        super().__init__()
        self.channels_last = channels_last
        self.collapsible_shapes = None
        self.collapsed_shape = None
        self.dtype = None
        self.n_features = None

    def _set_shapes_from_data(self, data: np.ndarray = None) -> None:
        """

        Args:
            data (np.ndarray, optional): The input data to reshape. (Default value = None)
        Example:

            >>> reshaper = Reshaper()
            >>> reshaper._set_shapes_from_data(np.random.random((10,3,4,5)))
            >>> reshaper.collapsible_shapes
            (3, 4, 5)
        """

        self.collapsible_shapes = data.shape[1:]
        self.collapsed_shape = np.prod(self.collapsible_shapes).astype(int)
        self._is_recarray = data.dtype.names is not None
        if self._is_recarray:
            self.n_features = len(data.dtype.names) * self.collapsed_shape
        else:
            self.n_features = self.collapsed_shape

    def _prepare_input_data(self, data: np.ndarray = None) -> np.ndarray:
        """

        Args:
            data (np.ndarray, optional):  (Default value = None)

        Returns:
            np.ndarray:

        Note:
            This function reshapes the input data to (n0, prod(n1, ..., nm)) shape.
        Example:

            >>> reshaper = Reshaper()
            >>> data = np.random.random((10,3,4,5))
            >>> reshaper.prepare_input_data(data)
            array([[0.527, 0.936, ... , 0.812],
                  [0.947, 0.865, ... , 0.947],
                  ...,
                  [0.865, 0.947, ... , 0.865],
                  [0.947, 0.865, ... , 0.947]])
        """

        assert len(data.shape) > 1, "Error! data must have at least two dimensions"
        return data.reshape((data.shape[0], self.n_features))

    def prepare_input_data(self, data: Union[np.ndarray, np.recarray]) -> np.ndarray:
        """Prepare input data for reshaping.

        Args:
            data (Union[np.ndarray, np.recarray]):

        Returns:
            np.ndarray:

        Note:
            - If `data` is a structured numpy array, it will be passed to `_prepare_input_structured_data` function.
            - If `data` is a plain numpy array, it will be passed to `_prepare_input_data` function.
        Example:

            >>> reshaper = Reshaper()
            >>> input_data = np.random.rand(2, 3, 4)
            >>> reshaper.prepare_input_data(input_data)
            array([[ 0.948...,  0.276...,  0.967...,  0.564...],
                [ 0.276...,  0.948...,  0.564...,  0.967...],
                [ 0.276...,  0.948...,  0.564...,  0.967...],
                [ 0.948...,  0.276...,  0.967...,  0.564...],
                [ 0.276...,  0.948...,  0.564...,  0.967...],
                [ 0.276...,  0.948...,  0.564...,  0.967...]])
        """

        self._set_shapes_from_data(data)
        if self._is_recarray:
            return self._prepare_input_structured_data(data)
        else:
            return self._prepare_input_data(data)

    def _reshape_to_output(self, data: np.ndarray) -> np.ndarray:
        """Reshape the data to its original shape before reshaping.

        Args:
            data (np.ndarray):

        Returns:
            np.ndarray:

        Note:
            The original shape of the data is stored in `collapsible_shapes` attribute.
        Example:

            >>> reshaper = Reshaper()
            >>> input_data = np.random.rand(2, 3, 4)
            >>> reshaper._set_shapes_from_data(input_data)
            >>> reshaped_data = reshaper._reshape_to_output(input_data.flatten())
            >>> reshaped_data.shape
            (2, 3, 4)
        """

        return data.reshape((data.shape[0],) + self.collapsible_shapes)

    def _prepare_output_data(
        self, data: np.ndarray = None, single: bool = False
    ) -> np.ndarray:
        """Prepare the input data to be in the shape and format expected by the model.

        Args:
            data (np.ndarray, optional): The input data to be prepared, by default None
            single (bool, optional):  (Default value = False)

        Returns:
            np.ndarray: The prepared input data

        """
        if self._is_recarray:
            return self._prepare_output_structured_data(data)
        else:
            return self._reshape_to_output(data)

    def prepare_output_data(self, data: np.ndarray, single: bool = False) -> np.ndarray:
        """Prepare the input data to be in the shape and format expected by the model.

        Args:
            data (np.ndarray): The input data to be prepared
            single (bool, optional):  (Default value = False)

        Returns:
            np.ndarray: The prepared input data

        """
        return self._prepare_output_data(data)

    def _prepare_input_structured_data(self, data: np.recarray = None) -> np.ndarray:
        """Prepare the input structured data to be in the shape and format expected by the model.

        Args:
            data (np.recarray, optional):  (Default value = None)

        Returns:
            np.ndarray: The prepared input structured data

        """
        self.dtype = data.dtype
        self._set_shapes_from_data(data)
        data_ = recfunctions.structured_to_unstructured(data)
        reshaped_data_ = self._prepare_input_data(data_)
        return reshaped_data_

    def prepare_input_structured_data(self, data: np.recarray = None) -> np.ndarray:
        """Prepare the input structured data to be in the shape and format expected by the model.

        Args:
            data (np.recarray, optional):  (Default value = None)

        Returns:
            np.ndarray: The prepared input structured data

        """
        return self._prepare_input_structured_data(data)

    def prepare_output_structured_data(self, data: np.ndarray = None) -> np.recarray:
        """Prepare the output data to be in the shape and format expected by the user.

        Args:
            data (np.ndarray, optional):  (Default value = None)

        Returns:
            np.recarray: The prepared output structured data

        """
        return self._prepare_output_structured_data(data)

    def _prepare_output_structured_data(self, data: np.ndarray = None) -> np.recarray:
        """Prepare the output data to be in the shape and format expected by the user.

        Args:
            data (np.ndarray, optional):  (Default value = None)

        Returns:
            np.recarray: The prepared output structured data

        """
        data = data.reshape(
            (data.shape[0],) + self.collapsible_shapes + (len(self.dtype),)
        )
        output_data = recfunctions.unstructured_to_structured(data, self.dtype)
        output_data = self._reshape_to_output(output_data)
        return output_data

class ScalerReshaper(Reshaper):

    """ScalerReshaper is a class that inherits from the Reshaper class and performs additional scaling on the input data."""

    name = "scalerreshaper"

    def __init__(
        self, bias: float = 0.0, scale: float = 1.0, channels_last: bool = False
    ) -> None:
        """Reshaper converts n-dimensional arrays to two-dimensional ones, performing a
        simple reshaping operation F: (n0, n1, ..., nm) -> (n0, prod(n1, ..., nm))

        Args:
            bias (float, optional):  (Default value = 0.0)
            scale (float, optional):  (Default value = 1.0)
            channels_last (bool, optional):  (Default value = False)
        """
        super().__init__(channels_last=channels_last)
        self.bias = bias
        self.scale = scale

    def prepare_input_data(
        self, data: Union[np.ndarray, np.recarray] = None, *args, **kwargs
    ) -> np.ndarray:
        """Prepare the input data by subtracting the bias and scaling the data.

        Args:
            data (Union[np.ndarray, np.recarray], optional): The input data to be prepared (Default value = None)
            *args:
            **kwargs:

        Returns:
            np.ndarray: The prepared input data

        Note:
            If the input data is a structured array, the method 'prepare_input_structured_data' will be called instead.
        Example:

            >>> reshaper = ScalerReshaper(bias=10, scale=2)
            >>> reshaper.prepare_input_data(np.array([1, 2, 3]))
            array([-4.5, -3.5, -2.5])
        """

        if data.dtype.names is None:
            return super(ScalerReshaper, self).prepare_input_data(
                (data - self.bias) / self.scale, *args, **kwargs
            )
        else:
            return self.prepare_input_structured_data(data, *args, **kwargs)

    def prepare_output_data(
        self, data: Union[np.ndarray, np.recarray] = None, *args, **kwargs
    ) -> np.ndarray:
        """Prepare the output data by scaling it and adding the bias.

        Args:
            data (Union[np.ndarray, np.recarray], optional): The output data to be prepared (Default value = None)
            *args:
            **kwargs

        Returns:
            np.ndarray: The prepared output data

        Note:
            If the input data is a structured array, the method 'prepare_output_structured_data' will be called
        Example:

            >>> reshaper = ScalerReshaper(bias=10, scale=2)
            >>> reshaper.prepare_output_data(np.array([1, 2, 3]))
            array([12., 14., 16.])
        """

        if not self._is_recarray:
            return super(ScalerReshaper, self).prepare_output_data(
                data * self.scale + self.bias, *args, **kwargs
            )
        else:
            return self.prepare_output_structured_data(data)

    def _get_structured_bias_scale(self, dtype: np.dtype = None) -> Tuple[dict, dict]:
        """Get the bias and scale values for each field of a structured array.

        Args:
            dtype (np.dtype, optional):  (Default value = None)

        Returns:
            Tuple[dict, dict]: A tuple of two dictionaries, the first containing the bias values for each field and the second

        Note:
            If the bias and scale attributes are floats, they will be used for all fields.
        Example:

            >>> reshaper = ScalerReshaper(bias=10, scale=2)
            >>> reshaper._get_structured_bias_scale(np.dtype([('a', float), ('b', float)]))
            ({'a': 10, 'b': 10}, {'a': 2, 'b': 2})
        """

        bias = self.bias
        if isinstance(self.bias, float):
            bias = {n: self.bias for n in dtype.names}
        scale = self.scale
        if isinstance(self.scale, float):
            scale = {n: self.scale for n in dtype.names}

        return bias, scale

    def prepare_input_structured_data(
        self, data: np.recarray = None, *args, **kwargs
    ) -> np.ndarray:
        """Scale and reshape structured data (np.recarray) before passing it to the next layer.

        Args:
            data (np.recarray, optional): structured data to be transformed (Default value = None)
            *args (Additional arguments passed to the parent class):
            **kwargs

        Returns:
            np.ndarray:

        Note:
            The bias and scale parameters are expected to be provided in the form of dictionaries, where keys are field names and values are the corresponding bias and scale values for those fields.
        Example:

            >>> data = np.array([(1, 2, 3), (4, 5, 6)], dtype=[("a", int), ("b", int), ("c", int)])
            >>> reshaper = ScalerReshaper(bias={'a': 1, 'b': 2, 'c': 3}, scale={'a': 2, 'b': 3, 'c': 4})
            >>> reshaper.prepare_input_structured_data(data)
                array([[-0.5, 0.33333333, 0.75      ],
                    [ 1.5, 1.66666667, 2.        ]])
        """

        bias, scale = self._get_structured_bias_scale(data.dtype)
        data = data.copy()
        names = data.dtype.names
        for name in names:
            data[name] = (data[name] - bias[name]) / scale[name]
        return super(ScalerReshaper, self).prepare_input_structured_data(
            data, *args, **kwargs
        )

    def prepare_output_structured_data(
        self, data: np.ndarray = None, *args, **kwargs
    ) -> np.recarray:
        """Scale and reshape structured data (np.recarray) before passing it to the next layer.

        Args:
            data (np.ndarray, optional): structured data to be transformed (Default value = None)
            *args (Additional arguments passed to the parent class):
            **kwargs:

        Returns:
            np.recarray:

        Note:
            - The bias and scale parameters are expected to be provided in the form of dictionaries, where keys are field names and values are the corresponding bias and scale values for those fields.
        Example:

            >>> data = np.array([[-0.5, 0.33333333, 0.75      ],
            >>>                  [ 1.5, 1.66666667, 2.        ]])
            >>> reshaper = ScalerReshaper(bias={'a': 1, 'b': 2, 'c': 3}, scale={'a': 2, 'b': 3, 'c': 4})
            >>> reshaper.prepare_output_structured_data(data)
            rec.array([(0., 2.,  6.), (6., 8., 12.)],
                dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])
        """

        bias, scale = self._get_structured_bias_scale(self.dtype)
        data = super(ScalerReshaper, self).prepare_output_structured_data(
            data, *args, **kwargs
        )
        data = data.copy()
        for name in self.dtype.names:
            data[name] = data[name] * scale[name] + bias[name]
        return data

class MapValid(Reshaper):
    """MapValid is a reshaper class that converts n-dimensional arrays to two-dimensional ones performing a valid values
    mapping operation F: F: data.shape = (n0, n1, ..., nm) -> data'.shape = (n0, n_valids)
    where n_valids is the number of valid elements in the data array.
    This class is useful for datasets in which there are invalid data.

    """

    name = "map_valid"

    def __init__(
        self, config: dict = None, mask=None, channels_last: bool = True
    ) -> None:
        """Initialize the MapValid class with the configurations and mask passed as parameters.

        Args:
            config (dict, optional): configurations dictionary, by default None
            mask (int, np.NaN, np.inf, optional, optional): mask to select the invalid values, by default None
            channels_last (bool, optional): if set to True, move the channel dimension to the last, by default True

        """
        super().__init__()

        self.default_dtype = "float64"

        if mask == 0 or isinstance(mask, int):
            self.replace_mask_with_large_number = False
        else:
            self.replace_mask_with_large_number = True

        self.return_the_same_mask = True

        for key, value in config.items():
            setattr(self, key, value)

        # Default value for very large numbers
        self.large_number = 1e15

        if not mask or self.replace_mask_with_large_number:
            self.mask = self.large_number
        else:
            self.mask = mask

        self.mask_ = mask

        for key, value in config.items():
            setattr(self, key, value)

        self.valid_indices = None
        self.original_dimensions = None

        self.channels_last = channels_last

    def prepare_input_data(self, data: np.ndarray = None) -> np.ndarray:
        """Internal input data preparer, executed for each label of the structured array

        Args:
            data (np.ndarray, optional):  (Default value = None)

        Returns:
            np.ndarray:

        Note:
            - MapValid converts n-dimensional arrays to two-dimensional ones performing a valid values
            mapping operation F: F: data.shape = (n0, n1, ..., nm) -> data'.shape = (n0, n_valids)
            n_valids = dim([k in data[0, ...] if k != mask])
            - WARNING: the invalid positions are expected to be static in relation to n0.
        Example:

            >>> data = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
            >>> prepare_input_data(data)
            array([[1, 2, 3],
                   [5, 6, 7],
                   [9, 10, 11]])
        """

        data = super(MapValid, self).prepare_input_data(data)

        if self.mask == self.large_number:
            self.valid_indices_ = np.where(data[0, ...] < self.mask)

        elif not str(self.mask).isnumeric() or isinstance(self.mask, int):
            self.valid_indices_ = np.where(data[0, ...] != self.mask)

        else:
            raise Exception(
                "The chosen mask {} does not fit in any supported case".format(
                    self.mask
                )
            )

        samples_dim = data.shape[0]

        valid_indices = (slice(0, samples_dim),) + self.valid_indices_

        return data[valid_indices]

    def prepare_output_data(self, data: np.ndarray = None) -> np.ndarray:
        """Prepare output data for the MapValid operation.

        Args:
            data (np.ndarray, optional):  (Default value = None)

        Returns:
            np.ndarray:

        Note:
            - The reshaped data will have shape (n0, n_valids) where n0 is the number of samples and n_valids are the number of valid values in the data.
            - If the return_the_same_mask attribute is set to True, the mask used to select the invalid values will be returned. Otherwise, the reshaped data will be filled with NaN.
        Example:

            >>> import numpy as np
            >>> reshaper = MapValid()
            >>> data = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
            >>> reshaper.prepare_output_data(data)
            array([[[ 1.,  2.,  3.],
                    [ 4.,  5.,  6.]],
        """

        immutable_shape = data.shape[0]

        final_shape = (
            immutable_shape,
            self.n_features,
        )

        if self.return_the_same_mask:
            mask = self.mask_
        else:
            mask = np.NaN  # For practical purposes
        reshaped_data = np.full(final_shape, mask)

        if not reshaped_data.dtype.type == self.default_dtype:
            reshaped_data = reshaped_data.astype(self.default_dtype)

        samples_dim = data.shape[0]
        valid_indices = (slice(0, samples_dim),) + self.valid_indices_

        reshaped_data[valid_indices] = data

        reshaped_data = super(MapValid, self).prepare_output_data(reshaped_data)

        return reshaped_data

    def prepare_input_structured_data(self, data: np.recarray = None) -> np.ndarray:
        """This function is used to prepare structured input data for further processing.

        Args:
            data (np.recarray, optional):  (Default value = None)

        Returns:
            np.ndarray:

        Note:
            This function is a wrapper function that calls the 'prepare_input_data' function internally.
        Example:

            >>> import numpy as np
            >>> data = np.array([(1, 2, 3), (4, 5, 6)], dtype=[('a', int), ('b', int), ('c', int)])
            >>> model = MapValid()
            >>> prepared_data = MapValid.prepare_input_structured_data(data)
            >>> prepared_data
            array([[1, 2, 3],
                  [4, 5, 6]])
        """

        return self.prepare_input_data(data)

    def prepare_output_structured_data(self, data: np.ndarray = None) -> np.ndarray:
        """This function is used to prepare structured output data for further processing.

        Args:
            data (np.ndarray, optional):  (Default value = None)

        Returns:
            np.ndarray:

        Note:
            This function is a wrapper function that calls the 'prepare_output_data' function internally.
        Example:

            >>> import numpy as np
            >>> data = np.array([[1, 2, 3], [4, 5, 6]])
            >>> model = MapValid()
            >>> prepared_data = MapValid.prepare_output_structured_data(data)
            >>> prepared_data
            array([[1, 2, 3],
                [4, 5, 6]])
        """

        return self.prepare_output_data(data)

class Sampling(DataPreparer):
    """This class is used for sampling data from the input dataset."""

    name = "sampling"

    def __init__(self, choices_fraction: float = 0.1, shuffling: bool = False) -> None:
        """Initializes the Sampling class.

        Args:
            choices_fraction (float, optional): The fraction of the dataset to be sampled, by default 0.1
            shuffling (bool, optional): Whether to shuffle the data before sampling, by default False

        """

        super().__init__()
        self.choices_fraction = choices_fraction
        self.shuffling = shuffling
        self.global_indices = None
        self.sampled_indices = None

    @property
    def indices(self) -> list:
        """Returns the indices of the data that have been sampled.

        Returns:
            list: The indices of the data that have been sampled.

        Raises:
            AssertionError: If the indices have not been generated yet.

        Note:
            The indices are generated by calling the 'prepare_input_data' or 'prepare_input_structured_data' functions.
        Example:

            >>> import numpy as np
            >>> data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
            >>> sampler = Sampling(choices_fraction=0.5, shuffling=True)
            >>> sampler.prepare_input_data(data)
            >>> sampler.indices
            [0, 1]
        """

        assert self.sampled_indices is not None, (
            "The indices still were not generate."
            "Run prepare_input_data or prepare_input_structured_data for getting them."
        )
        return sorted(self.sampled_indices.tolist())

    def prepare_input_data(
        self, data: np.ndarray = None, data_interval: list = None
    ) -> np.ndarray:
        """Prepare input data for sampling.

        Args:
            data (np.ndarray, optional): The input data. Default is None.
            data_interval (list, optional): The interval of data that should be selected. Default is None,

        Returns:
            numpy.ndarray: The sampled data.
        Note:
            The `data_interval` parameter must be a list of two integers, specifying the start and end of the interval.
         Example:

            >>> data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
            >>> data_interval = [3, 7]
            >>> input_data = sampler.prepare_input_data(data, data_interval)
        """

        if data_interval is None:
            data_interval = [0, data.shape[0]]
        n_samples = data_interval[1] - data_interval[0]

        self.global_indices = np.arange(start=data_interval[0], stop=data_interval[1])

        n_choices = int(self.choices_fraction * n_samples)

        self.sampled_indices = self.global_indices.copy()
        if self.shuffling:
            np.random.shuffle(self.sampled_indices)
        else:
            self.sampled_indices = self.sampled_indices

        self.sampled_indices = np.random.choice(self.sampled_indices, n_choices)

        return data[self.sampled_indices]

    def prepare_input_structured_data(
        self,
        data: h5py.Dataset = None,
        data_interval: list = None,
        batch_size: int = None,
        dump_path: str = None,
    ) -> np.recarray:
        """Prepares structured data for further processing.

        Args:
            data (h5py.Dataset, optional): Structured array to be prepared, the default shape is (n_samples, 1, *other_dimensions)
            data_interval (list, optional): The interval of the data to be prepared, the default shape is [0, data.shape[0]]
            batch_size (int, optional): The size of the batches to be processed, defaults to None
            dump_path (str, optional):  (Default value = None)

        Returns:
            np.recarray:

        Note:
            - The features dimensions of the input data should be 1 in NumPy structured arrays.
            - When using a h5py.Dataset as input, a dump_path must be provided
        Example:

            >>> data = h5py.File("path/to/data.h5", 'r')['data']
            >>> data_interval = [0, data.shape[0]]
            >>> batch_size = 32
            >>> dump_path = "path/to/dump.h5"
            >>> obj = PrepareInputStructuredData()
            >>> prepared_data = obj.prepare_input_structured_data(data, data_interval, batch_size, dump_path)
        """

        if data_interval is None:
            data_interval = [0, data.shape[0]]

        n_samples = data_interval[1] - data_interval[0]
        self.global_indices = np.arange(start=data_interval[0], stop=data_interval[1])

        n_sampled_preserved = int(self.choices_fraction * n_samples)
        self.sampled_indices = np.random.choice(
            self.global_indices, n_sampled_preserved, replace=False
        )

        if isinstance(data, h5py.Dataset):
            if isinstance(batch_size, MemorySizeEval):
                batch_size = batch_size(
                    max_batches=n_sampled_preserved, shape=data.shape[1:]
                )
            else:
                pass

            assert (
                dump_path
            ), "Using a h5py.Dataset as input data a dump_path must be provided."

            fp = h5py.File(dump_path, "w")
            sampled_data = fp.create_dataset(
                "data", shape=(n_sampled_preserved,) + data.shape[1:], dtype=data.dtype
            )

            # Constructing the normalization  using the reference data
            batches = indices_batchdomain_constructor(
                indices=self.sampled_indices, batch_size=batch_size
            )

            start_ix = 0
            for batch_id, batch in enumerate(batches):
                print(
                    f"Sampling batch {batch_id+1}/{len(batches)} batch_size={len(batch)}"
                )
                finish_ix = start_ix + len(batch)
                sampled_data[start_ix:finish_ix] = data[sorted(batch)]
                start_ix = finish_ix

            if self.shuffling:
                random.shuffle(sampled_data)

        else:
            raise Exception("Others cases are still not implemented.")

        return sampled_data

class MovingWindow:
    r"""MovingWindow is applied over a time-series array (2D array), and it is used for
    creating the necessary augmented data used for LSTM networks, replicating the training
    windows for each sample in the dataset.

    See a graphical example:

    Example:

        batch n
        ---------|---
        history  | horizon

            batch n+1
            ---------|---
            history  | horizon
        ----
        skip

    Example:

        >>> import numpy as np
        >>> data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
        >>> window = MovingWindow(history_size=3, horizon_size=1)
        >>> window.transform(data)
        array([[1, 2, 3],
               [2, 3, 4],
               [3, 4, 5],
               [4, 5, 6],
               [5, 6, 7],
               [6, 7, 8],
               [7, 8, 9],
               [8, 9, 10]])
    """

    def __init__(
        self,
        history_size: int = None,
        skip_size: int = 1,
        horizon_size: int = None,
        full_output: bool = True,
    ) -> None:
        r"""Initializes the MovingWindow class

        Args:
            history_size (int, optional): the size of the history window, by default None
            skip_size (int, optional): the number of steps to skip between windows, by default 1
            horizon_size (int, optional): the size of the horizon window, by default None
            full_output (bool, optional): flag to use the full output or only the last item, by default True

        """
        self.history_size = history_size
        self.skip_size = skip_size
        self.horizon_size = horizon_size
        self.full_output = full_output

        if self.full_output == True:
            self.process_batch = self.bypass
        else:
            self.process_batch = self.get_last_item

        # Verifying if history and horizon sizes was provided
        assert (
            history_size
        ), f"A value for history_size must be provided, not {history_size}"
        assert (
            horizon_size
        ), f"A value for horizon_size must be provided, not {horizon_size}"

    def transform(self, time_series: np.ndarray) -> np.ndarray:
        r"""Applies the moving window over the time_series array.

        Args:
            time_series (np.ndarray):

        Returns:
            np.ndarray: the transformed array with the windows.

        """
        return np.ndarray(time_series)

    def bypass(self, batch: np.ndarray) -> np.ndarray:
        r"""Does nothing, returns the input batch.

        Args:
            batch (np.ndarray):

        Returns:
            np.ndarray: the input array

        """
        return batch

    def get_last_item(self, batch: np.ndarray) -> np.ndarray:
        r"""Get the last item of a batch

        Args:
            batch (np.ndarray):

        Returns:
            np.ndarray:

        Note:
            - This method is used internally by the MovingWindow class
        Example:

            >>> data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
            >>> mw.get_last_item(data)
            array([[7, 8, 9]])
        """

        return batch[-1:]

    def __call__(
        self, input_data: np.ndarray = None, output_data: np.ndarray = None
    ) -> Tuple[np.ndarray, np.ndarray]:
        r"""Apply Moving Window over the input data

        Args:
            input_data (np.ndarray, optional): 2D array (time-series) to be used for constructing the history size (Default value = None)
            output_data (np.ndarray, optional):  (Default value = None)

        Returns:
            Tuple of np.ndarray: The tuple contains two arrays with shapes (n_samples, n_history, n_features) and

        Note:
            - It is expected that the input_data and output_data have the same shape
            - This method is used internally by the MovingWindow class
        Example:

            >>> data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]])
            >>> mw = MovingWindow(history_size=2, horizon_size=2, skip_size=1)
            >>> input_data, output_data = mw(data, data)
            >>> input_data
            array([[[1, 2, 3],
                    [4, 5, 6]],
                   [[4, 5, 6],
                    [7, 8, 9]],
                   [[7, 8, 9],
                    [10, 11, 12]]])
            >>> output_data
            array([[[ 7,  8,  9],
                    [10, 11, 12]],
                   [[10, 11, 12],
                    [13, 14, 15]]])
        """

        # It is expected series_data to be a set of time-series with shape
        # (n_timesteps, n_variables)

        input_batches_list = list()
        output_batches_list = list()
        data_size = input_data.shape[0]

        assert input_data.shape[0] == output_data.shape[0]

        center = self.history_size

        # Loop for covering the entire time-series dataset constructing the
        # training windows
        while center + self.horizon_size <= data_size:
            input_batch = input_data[center - self.history_size : center, :]
            output_batch = output_data[center : center + self.horizon_size, :]

            input_batches_list.append(input_batch)
            output_batches_list.append(self.process_batch(batch=output_batch))

            center += self.skip_size

        input_data = np.stack(input_batches_list, 0)
        output_data = np.stack(output_batches_list, 0)

        return input_data, output_data