"""simple docstring"""



import importlib.util
import json
import os
import warnings
from dataclasses import dataclass, field

import torch

from ..training_args import TrainingArguments
from ..utils import cached_property, is_sagemaker_dp_enabled, logging


SCREAMING_SNAKE_CASE__:Optional[int]			=	logging.get_logger(__name__)



def 					_lowerCamelCase(					):
							# Get the sagemaker specific mp parameters from smp_options variable.
							__a     				=  os.getenv("SM_HP_MP_PARAMETERS" ,  "{}"							)
							try:
														# Parse it and check the field "partitions" is included, it is required for model parallel.
														__a     				=  json.loads(a							)
														if "partitions" not in smp_options:
																					return False
							except json.JSONDecodeError:
														return False

							# Get the sagemaker specific framework parameters from mpi_options variable.
							__a     				=  os.getenv("SM_FRAMEWORK_PARAMS" ,  "{}"							)
							try:
														# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
														__a     				=  json.loads(a							)
														if not mpi_options.get("sagemaker_mpi_enabled" ,  a							):
																					return False
							except json.JSONDecodeError:
														return False
							# Lastly, check if the `smdistributed` module is present.
							return importlib.util.find_spec("smdistributed"							) is not None


if is_sagemaker_model_parallel_available():
			import smdistributed.modelparallel.torch as smp

			smp.init()






@dataclass
class 				snake_case__     (   snake_case_   ):
	_snake_case   :			str           =		field(
	    default="""""",		metadata={"""help""": """Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"""},		)


	def 		a__ (				self		):
								super().__post_init__()
								warnings.warn(
								    "`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use "
								    "`TrainingArguments` instead."  ,						lowerCamelCase  ,						)


	@cached_property
	def 		a__ (				self		):
								logger.info("PyTorch: setting up devices"		)
								if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1:
															logger.warning(
															    "torch.distributed process group is initialized, but local_rank == -1. "
															    "In order to use Torch DDP, launch your script with `python -m torch.distributed.launch"		)
								if self.no_cuda:
															__a     				=  torch.device("cpu"		)
															__a     				=  0
								elif is_sagemaker_model_parallel_available():
															__a     				=  smp.local_rank()
															__a     				=  torch.device("cuda"  ,						lowerCamelCase		)
															__a     				=  1
								elif is_sagemaker_dp_enabled():
															import smdistributed.dataparallel.torch.torch_smddp  # noqa: F401

															torch.distributed.init_process_group(backend="smddp"  ,						timeout=self.ddp_timeout_delta		)
															__a     				=  int(os.getenv("SMDATAPARALLEL_LOCAL_RANK"		)		)
															__a     				=  torch.device("cuda"  ,						self.local_rank		)
															__a     				=  1
								elif self.local_rank == -1:
															# if n_gpu is > 1 we'll use nn.DataParallel.
															# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
															# Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will
															# trigger an error that a device index is missing. Index 0 takes into account the
															# GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0`
															# will use the first GPU in that env, i.e. GPU#1
															__a     				=  torch.device("cuda:0" if torch.cuda.is_available() else "cpu"		)
															# Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at
															# the default value.
															__a     				=  torch.cuda.device_count()
								else:
															# Here, we'll use torch.distributed.
															# Initializes the distributed backend which will take care of synchronizing nodes/GPUs
															if not torch.distributed.is_initialized():
																						torch.distributed.init_process_group(backend="nccl"  ,						timeout=self.ddp_timeout_delta		)
															__a     				=  torch.device("cuda"  ,						self.local_rank		)
															__a     				=  1

								if device.type == "cuda":
															torch.cuda.set_device(lowerCamelCase		)

								return device


	@property
	def 		a__ (				self		):
								if is_sagemaker_model_parallel_available():
															return smp.dp_size()

								return super().world_size


	@property
	def 		a__ (				self		):
								return not is_sagemaker_model_parallel_available()






	@property
	def 		a__ (				self		):
								return False

"""simple docstring"""



from ...processing_utils import ProcessorMixin






class 				snake_case__     (   snake_case_   ):
 _snake_case   :			List[str]           =		"""WhisperFeatureExtractor"""
 _snake_case   :			Any           =		"""WhisperTokenizer"""


 def __init__(				self  ,						lowerCamelCase  ,						lowerCamelCase		):
        super().__init__(lowerCamelCase  ,						lowerCamelCase		)
        __a     				=  self.feature_extractor
        __a     				=  False


 def 		a__ (				self  ,						lowerCamelCase=None  ,						lowerCamelCase=None  ,						lowerCamelCase=True		):
        return self.tokenizer.get_decoder_prompt_ids(task=lowerCamelCase  ,						language=lowerCamelCase  ,						no_timestamps=lowerCamelCase		)


 def __call__(				self  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        # For backward compatibility
        if self._in_target_context_manager:
               return self.current_processor(*lowerCamelCase  ,						**lowerCamelCase		)

        __a     				=  kwargs.pop("audio"  ,						lowerCamelCase		)
        __a     				=  kwargs.pop("sampling_rate"  ,						lowerCamelCase		)
        __a     				=  kwargs.pop("text"  ,						lowerCamelCase		)
        if len(lowerCamelCase		) > 0:
               __a     				=  args[0]
               __a     				=  args[1:]

        if audio is None and text is None:
               raise ValueError("You need to specify either an `audio` or `text` input to process."		)

        if audio is not None:
               __a     				=  self.feature_extractor(lowerCamelCase  ,						*lowerCamelCase  ,						sampling_rate=lowerCamelCase  ,						**lowerCamelCase		)
        if text is not None:
               __a     				=  self.tokenizer(lowerCamelCase  ,						**lowerCamelCase		)

        if text is None:
               return inputs

        elif audio is None:
               return encodings
        else:
               __a     				=  encodings["input_ids"]
               return inputs


 def 		a__ (				self  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        return self.tokenizer.batch_decode(*lowerCamelCase  ,						**lowerCamelCase		)


 def 		a__ (				self  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        return self.tokenizer.decode(*lowerCamelCase  ,						**lowerCamelCase		)






 def 		a__ (				self  ,						lowerCamelCase  ,						lowerCamelCase="np"		):
        return self.tokenizer.get_prompt_ids(lowerCamelCase  ,						return_tensors=lowerCamelCase		)
