


"""simple docstring"""




import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
class 					__lowerCAmelCase					(   __SCREAMING_SNAKE_CASE       ):


		'''simple docstring'''



		__UpperCAmelCase		:			Optional[Any]										=				'Speech2TextFeatureExtractor'
		__UpperCAmelCase		:			Any										=				'Speech2TextTokenizer'

		def __init__(  self							, _a							, _a      ):
				super().__init__(_a							, _a      )
				__a           =			self.feature_extractor
				__a           =			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.'''      )
						__a           =			kwargs.pop('''raw_speech'''      )
				else:
						__a           =			kwargs.pop('''audio'''							, _a      )
				__a           =			kwargs.pop('''sampling_rate'''							, _a      )
				__a           =			kwargs.pop('''text'''							, _a      )
				if len(_a      ) > 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(_a							, *_a							, sampling_rate=_a							, **_a      )
				if text is not None:
						__a           =			self.tokenizer(_a							, **_a      )

				if text is None:
						return inputs
				elif audio is None:
						return encodings
				else:
						__a           =			encodings['''input_ids''']
						return inputs

		def 			__UpperCAmelCase       (  self							, *_a							, **_a      ):
				return self.tokenizer.batch_decode(*_a							, **_a      )

		def 			__UpperCAmelCase       (  self							, *_a							, **_a      ):
				return self.tokenizer.decode(*_a							, **_a      )





		@contextmanager
		def 			__UpperCAmelCase       (  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.'''      )
				__a           =			True
				__a           =			self.tokenizer
				yield
				__a           =			self.feature_extractor
				__a           =			False










"""simple docstring"""




import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment
class 					__lowerCAmelCase					(   unittest.TestCase       ):


		'''simple docstring'''



		def 			__UpperCAmelCase       (  self      ):
				__a           =			inspect.getfile(accelerate.test_utils      )
				__a           =			os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_script.py''']      )
				__a           =			os.path.sep.join(
				    mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_distributed_data_loop.py''']      )
				__a           =			os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_ops.py''']      )

		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices.'''      )
				__a           =			['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.test_file_path]
				with patch_environment(omp_num_threads=1      ):
						execute_subprocess_async(_a							, env=os.environ.copy()      )

		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices.'''      )
				__a           =			['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.operation_file_path]
				print(f'''Command: {cmd}'''      )
				with patch_environment(omp_num_threads=1      ):
						execute_subprocess_async(_a							, env=os.environ.copy()      )

		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				__a           =			['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', inspect.getfile(self.__class__      )]
				with patch_environment(omp_num_threads=1      ):
						execute_subprocess_async(_a							, env=os.environ.copy()      )





		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices, using 2 devices only'''      )
				__a           =			['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.data_loop_file_path]
				with patch_environment(omp_num_threads=1							, cuda_visible_devices='''0,1'''      ):
						execute_subprocess_async(_a							, env=os.environ.copy()      )


if __name__ == "__main__":
				lowercase_			     =  Accelerator()
				lowercase_			     =  (accelerator.state.process_index + 2, 1_0)
				lowercase_			     =  torch.randint(0, 1_0, shape).to(accelerator.device)

				lowercase_			     =  ""

				lowercase_			     =  accelerator.pad_across_processes(tensor)
				if tensora.shape[0] != accelerator.state.num_processes + 1:
								error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
				if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
								error_msg += "Tensors have different values."
				if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
								error_msg += "Padding was not done with the right value (0)."

				lowercase_			     =  accelerator.pad_across_processes(tensor, pad_first=True)
				if tensora.shape[0] != accelerator.state.num_processes + 1:
								error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
				lowercase_			     =  accelerator.state.num_processes - accelerator.state.process_index - 1
				if not torch.equal(tensora[index:], tensor):
								error_msg += "Tensors have different values."
				if not torch.all(tensora[:index] == 0):
								error_msg += "Padding was not done with the right value (0)."

				# Raise error at the end to make sure we don't stop at the first failure.
				if len(error_msg) > 0:
								raise ValueError(error_msg)






