content: from typing import Union, Tuple, List
  
  import numpy as np
  from batchgeneratorsv2.helpers.scalar_type import RandomScalar
  from batchgeneratorsv2.transforms.base.basic_transform import BasicTransform
  
  from nnunetv2.training.nnUNetTrainer.nnUNetTrainer import nnUNetTrainer
  
  
  class nnUNetTrainerNoDA(nnUNetTrainer):
      @staticmethod
      def get_training_transforms(
              patch_size: Union[np.ndarray, Tuple[int]],
              rotation_for_DA: RandomScalar,
              deep_supervision_scales: Union[List, Tuple, None],
              mirror_axes: Tuple[int, ...],
              do_dummy_2d_data_aug: bool,
              use_mask_for_norm: List[bool] = None,
              is_cascaded: bool = False,
              foreground_labels: Union[Tuple[int, ...], List[int]] = None,
              regions: List[Union[List[int], Tuple[int, ...], int]] = None,
              ignore_label: int = None,
      ) -> BasicTransform:
          return nnUNetTrainer.get_validation_transforms(deep_supervision_scales, is_cascaded, foreground_labels,
                                                         regions, ignore_label)
  
      def configure_rotation_dummyDA_mirroring_and_inital_patch_size(self):
          # we need to disable mirroring here so that no mirroring will be applied in inference!
          rotation_for_DA, do_dummy_2d_data_aug, _, _ = \
              super().configure_rotation_dummyDA_mirroring_and_inital_patch_size()
          mirror_axes = None
          self.inference_allowed_mirroring_axes = None
          initial_patch_size = self.configuration_manager.patch_size
          return rotation_for_DA, do_dummy_2d_data_aug, initial_patch_size, mirror_axes
  
  