Dataset

def complete_initialization(
    self, controller_kwargs: Dict[str, Any], to_format: DataReturnFormat
) -> None:
    """Finalize initialization of object to be able to recover items

    Args:
        path: path to dataset
        to_format: format associated to expected return format
    """

    self.path = controller_kwargs.get("root", None)
    if self.path is None:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Custom Dataset ERROR: 'root' must be provided in controller_kwargs to specify dataset location."
        )
    self._to_format = to_format

    # Call user defined read function to read the dataset
    try:
        self.read()
    except Exception as e:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Failed to read "
            f"from dataset using read method. Please see error: {e}"
        ) from e

    try:
        sample = self.get_item(0)
    except Exception as e:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Failed to retrieve item "
            f"from dataset using get_item method. Please see error: {e}"
        ) from e
    if not isinstance(sample, tuple) or len(sample) != 2:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: get_item method must return a tuple of two elements"
            f" (data, target), but got {type(sample).__name__} with"
            f" length {len(sample) if isinstance(sample, (list, tuple)) else 'N/A'}"
        )

    # Following line is just to check that dataset is well implemented
    # and it return correct data type respecting to to_format
    try:
        sample = self[0]
    except Exception as e:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Failed to retrieve item "
            f"from dataset using get_item method. Please see error: {e}"
        ) from e

@abstractmethod
def get_item(self, index):
    """Retrieves a sample and its label by index.

    Args:
        index (int): The index of the sample to retrieve.
    """
    pass

@abstractmethod
def read(self) -> None:
    """Reads the dataset from the specified path.

    This method should be implemented by subclasses to load the dataset
    from the given path and prepare it for use.
    """
    pass

def apply_transforms(self, sample: Dict[str, Any]) -> None:
    """Apply transforms to sample in place

    Args:
        sample: sample returned by `self._controller.get_sample`

    Raises:
        FedbiomedError: if there is a problem applying `transform` or `target_transform`
    """
    try:
        sample["data"] = self._transform(
            self._get_default_types_callable()(
                self._get_format_conversion_callable()(sample["data"])
            )
        )
    except Exception as e:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Failed to apply `transform` to `data` "
            f"in sample in {self._to_format.value} format."
        ) from e

    try:
        sample["data"] = self._get_default_types_callable()(sample["data"])
    except Exception as e:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Failed to apply default training plan types to `data` "
            f"in sample in {self._to_format.value} format."
        ) from e

    try:
        sample["target"] = self._target_transform(
            self._get_default_types_callable()(
                self._get_format_conversion_callable()(sample["target"])
            )
        )
    except Exception as e:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Failed to apply `target_transform` to "
            f"`target` in sample in {self._to_format.value} format."
        ) from e

    try:
        sample["target"] = self._get_default_types_callable()(sample["target"])
    except Exception as e:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Failed to apply default training plan types to `target` "
            f"in sample in {self._to_format.value} format."
        ) from e

    return sample

@abstractmethod
def complete_initialization(self) -> None:
    """Finalize initialization of object to be able to recover items"""
    # Recover sample and validate consistency of transforms
    pass

def complete_initialization(
    self,
    controller_kwargs: Dict[str, Any],
    to_format: DataReturnFormat,
) -> None:
    """Finalize initialization of object to be able to recover items

    Args:
        controller_kwargs: arguments to create controller
        to_format: format associated to expected return format
    """
    self.to_format = to_format
    self._init_controller(controller_kwargs=controller_kwargs)

    # Recover sample and validate consistency of transforms
    sample = self._controller.get_sample(0)
    self._validate_format_and_transformations(
        {modality: sample[modality] for modality in self._data_modalities},
        transform=self._transform,
    )
    if self._target_modalities is not None:
        self._validate_format_and_transformations(
            {modality: sample[modality] for modality in self._target_modalities},
            transform=self._target_transform,
            is_target=True,
        )

def complete_initialization(
    self,
    controller_kwargs: Dict[str, Any],
    to_format: DataReturnFormat,
) -> None:
    """Select data and target, and check if they can be converted to requested format.

    Args:
        controller_kwargs: keyword arguments for controller (not used here).
        to_format: format associated to expected return format.
    Raises:
        FedbiomedError: if there is a problem converting dataset items to requested format.
    """

    self._to_format = to_format
    self._converter = self._get_format_conversion_callable()

    if self._is_supervised:
        data, target = self._dataset[0]
    elif self._target is not None:
        data = self._dataset[0]
        target = self._target[0]
    else:
        data = self._dataset[0]
        target = None

    try:
        self._validate_format_conversion(data)
    except FedbiomedError as e:
        raise FedbiomedError(
            f"{ErrorNumbers.FB632.value}: Failed to convert dataset items to "
            f"requested format {to_format}. Details: {e}"
        ) from e

    if target is not None:
        try:
            self._validate_format_conversion(target)
        except FedbiomedError as e:
            raise FedbiomedError(
                f"{ErrorNumbers.FB632.value}: Failed to convert dataset items to "
                f"requested format {to_format}. Details: {e}"
            ) from e

def complete_initialization(  # type: ignore
    self,
    controller_kwargs: Dict[str, Any],
    to_format: DataReturnFormat,
) -> None:
    """Finalize initialization of object to be able to recover items

    Args:
        controller_kwargs: arguments to create controller
        to_format: format associated to expected return format
    """
    self.to_format = to_format

    self._init_controller(controller_kwargs=controller_kwargs)

    sample = self._controller.get_sample(0)  # type: ignore

    n_rows, _ = sample.shape
    if n_rows > 1:
        raise FedbiomedError(
            f"{ErrorNumbers.FB633.value}: TabularDataset currently only supports "
            "row-wise samples. Sample obtained from controller has multiple rows."
        )

    self._validate_format_and_transformations(
        self._get_inputs_from_sample(sample), transform=self._transform
    )
    self._validate_format_and_transformations(
        self._get_targets_from_sample(sample), transform=self._transform
    )