




"""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


a_				:    Optional[Any]										=     logging.get_logger(__name__)





def 						UpperCAmelCase				(			)  ->     Tuple:
			# Get the sagemaker specific mp parameters from smp_options variable.
			__lowerCamelCase					:	List[str]	       =				os.getenv('SM_HP_MP_PARAMETERS'							,				'{}'     )
			try:
						# Parse it and check the field "partitions" is included, it is required for model parallel.
						__lowerCamelCase					:	Optional[int]	       =				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.
			__lowerCamelCase					:	List[Any]	       =				os.getenv('SM_FRAMEWORK_PARAMS'							,				'{}'     )
			try:
						# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
						__lowerCamelCase					:	Any	       =				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 __lowercase(      lowercase__				):




					'''simple docstring'''


					__a						:						str     		= field(
					    default=''	,	metadata={'help': 'Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer'}	,	)
					def     snake_case_				(    self     ):
								super().__post_init__()
								warnings.warn(
								    '`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '
								    '`TrainingArguments` instead.'						,	__a						,	)
					@cached_property
					def     snake_case_				(    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:
											__lowerCamelCase					:	List[Any]	       =				torch.device('cpu'     )
											__lowerCamelCase					:	Any	       =				0
								elif is_sagemaker_model_parallel_available():
											__lowerCamelCase					:	Union[str, Any]	       =				smp.local_rank()
											__lowerCamelCase					:	Optional[int]	       =				torch.device('cuda'						,	__a     )
											__lowerCamelCase					:	List[str]	       =				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     )
											__lowerCamelCase					:	Tuple	       =				int(os.getenv('SMDATAPARALLEL_LOCAL_RANK'     )     )
											__lowerCamelCase					:	str	       =				torch.device('cuda'						,	self.local_rank     )
											__lowerCamelCase					:	str	       =				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
											__lowerCamelCase					:	Optional[Any]	       =				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.
											__lowerCamelCase					:	Optional[Any]	       =				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     )
											__lowerCamelCase					:	Tuple	       =				torch.device('cuda'						,	self.local_rank     )
											__lowerCamelCase					:	Dict	       =				1

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

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

								return super().world_size
					@property
					def     snake_case_				(    self     ):
								return not is_sagemaker_model_parallel_available()





					@property
					def     snake_case_				(    self     ):
								return False









"""simple docstring"""
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin

class __lowercase(      lowercase__				):




					'''simple docstring'''


					__a						:						List[str]     		= 'Speech2TextFeatureExtractor'
					__a						:						Optional[int]     		= 'Speech2TextTokenizer'
					def __init__(    self						,	__a						,	__a     ):
								super().__init__(__a						,	__a     )
								__lowerCamelCase					:	Union[str, Any]	       =				self.feature_extractor
								__lowerCamelCase					:	List[str]	       =				False
					def __call__(    self						,	*__a						,	**__a     ):
								# For backward compatibility
								if self._in_target_context_manager:
											return self.current_processor(*__a						,	**__a     )

								if "raw_speech" in kwargs:
											warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'     )
											__lowerCamelCase					:	str	       =				kwargs.pop('raw_speech'     )
								else:
											__lowerCamelCase					:	Optional[Any]	       =				kwargs.pop('audio'						,	__a     )
								__lowerCamelCase					:	Optional[Any]	       =				kwargs.pop('sampling_rate'						,	__a     )
								__lowerCamelCase					:	Optional[int]	       =				kwargs.pop('text'						,	__a     )
								if len(__a     ) > 0:
											__lowerCamelCase					:	Optional[int]	       =				args[0]
											__lowerCamelCase					:	str	       =				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:
											__lowerCamelCase					:	Dict	       =				self.feature_extractor(__a						,	*__a						,	sampling_rate=__a						,	**__a     )
								if text is not None:
											__lowerCamelCase					:	Optional[int]	       =				self.tokenizer(__a						,	**__a     )

								if text is None:
											return inputs
								elif audio is None:
											return encodings
								else:
											__lowerCamelCase					:	Any	       =				encodings['input_ids']
											return inputs
					def     snake_case_				(    self						,	*__a						,	**__a     ):
								return self.tokenizer.batch_decode(*__a						,	**__a     )
					def     snake_case_				(    self						,	*__a						,	**__a     ):
								return self.tokenizer.decode(*__a						,	**__a     )





					@contextmanager
					def     snake_case_				(    self     ):
								warnings.warn(
								    '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
								    'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
								    'your audio inputs, or in a separate call.'     )
								__lowerCamelCase					:	int	       =				True
								__lowerCamelCase					:	Union[str, Any]	       =				self.tokenizer
								yield
								__lowerCamelCase					:	Tuple	       =				self.feature_extractor
								__lowerCamelCase					:	List[str]	       =				False



