
"""simple docstring"""




import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
				import torch_xla.core.xla_model as xm  # noqa: F401

				lowercase__							:							Union[str, Any]													=     True
except ImportError:
				lowercase__							:							str													=     False


# Cache this result has it's a C FFI call which can be pretty time-consuming
lowercase__							:							Optional[Any]													=     torch.distributed.is_available()




def 		A_	(							snake_case							:				Union[str, Any]	) ->      Union[str, Any]:



						'''simple docstring'''

						__UpperCamelCase       					=     importlib.util.find_spec(snake_case	) is not None
						if package_exists:
												try:
																		__UpperCamelCase       					=     importlib.metadata.metadata(snake_case	)
																		return True
												except importlib.metadata.PackageNotFoundError:
																		return False




def 		A_	(							) ->      bool:



						'''simple docstring'''

						return _torch_distributed_available




def 		A_	(							) ->      str:



						'''simple docstring'''

						try:
												pass
						except ImportError:
												print(
												    '''Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not'''
												    ''' detected. If you see \"ValueError: Invalid backend: \'ccl\'\" error, please install Intel(R) oneCCL'''
												    ''' Bindings for PyTorch*.'''	)
						return (
						    importlib.util.find_spec('''torch_ccl'''	) is not None
						    or importlib.util.find_spec('''oneccl_bindings_for_pytorch'''	) is not None
						)




def 		A_	(							) ->      Tuple:



						'''simple docstring'''

						return importlib.metadata.version('''oneccl_bind_pt'''	)




def 		A_	(							) ->      Optional[Any]:



						'''simple docstring'''

						return _is_package_available('''transformer_engine'''	)




@lru_cache
def 		A_	(							snake_case							:				List[str]=True	) ->      int:



						'''simple docstring'''

						if torch.cuda.is_available():
												return False
						if _tpu_available and check_device:
												try:
																		# Will raise a RuntimeError if no XLA configuration is found
																		__UpperCamelCase       					=     xm.xla_device()
																		return True
												except RuntimeError:
																		return False
						return _tpu_available




def 		A_	(							) ->      int:



						'''simple docstring'''

						return _is_package_available('''deepspeed'''	)




def 		A_	(							snake_case							:				Any=False	) ->      int:



						'''simple docstring'''

						if is_tpu_available():
												return not ignore_tpu
						if torch.cuda.is_available():
												return torch.cuda.is_bfaa_supported()
						if is_npu_available():
												return False
						return True




def 		A_	(							) ->      str:



						'''simple docstring'''

						__UpperCamelCase       					=     _is_package_available('''bitsandbytes'''	)
						if package_exists:
												__UpperCamelCase       					=     version.parse(importlib.metadata.version('''bitsandbytes'''	)	)
												return compare_versions(snake_case	, '''>='''	, '''0.39.0'''	)
						return False




def 		A_	(							) ->      Any:



						'''simple docstring'''

						__UpperCamelCase       					=     _is_package_available('''bitsandbytes'''	)
						if package_exists:
												__UpperCamelCase       					=     version.parse(importlib.metadata.version('''bitsandbytes'''	)	)
												return compare_versions(snake_case	, '''>='''	, '''0.37.2'''	)
						return False




def 		A_	(							) ->      Optional[Any]:



						'''simple docstring'''

						return _is_package_available('''bitsandbytes'''	)




def 		A_	(							) ->      Any:



						'''simple docstring'''

						if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM'''	, '''False'''	)	) == 1:
												__UpperCamelCase       					=     importlib.util.find_spec('''megatron'''	) is not None
												if package_exists:
																		try:
																								__UpperCamelCase       					=     parse(importlib.metadata.version('''megatron-lm'''	)	)
																								return compare_versions(snake_case	, '''>='''	, '''2.2.0'''	)
																		except Exception as e:
																								warnings.warn(f"Parse Megatron version failed. Exception:{e}"	)
																								return False




def 		A_	(							) ->      Union[str, Any]:



						'''simple docstring'''

						return _is_package_available('''safetensors'''	)




def 		A_	(							) ->      Union[str, Any]:



						'''simple docstring'''

						return _is_package_available('''transformers'''	)




def 		A_	(							) ->      List[Any]:



						'''simple docstring'''

						return _is_package_available('''datasets'''	)




def 		A_	(							) ->      Any:



						'''simple docstring'''

						return _is_package_available('''aim'''	)




def 		A_	(							) ->      List[Any]:



						'''simple docstring'''

						return _is_package_available('''tensorboard'''	) or _is_package_available('''tensorboardX'''	)




def 		A_	(							) ->      str:



						'''simple docstring'''

						return _is_package_available('''wandb'''	)




def 		A_	(							) ->      Optional[int]:



						'''simple docstring'''

						return _is_package_available('''comet_ml'''	)




def 		A_	(							) ->      Dict:



						'''simple docstring'''

						return _is_package_available('''boto3'''	)




def 		A_	(							) ->      List[Any]:



						'''simple docstring'''

						if _is_package_available('''rich'''	):
												if "ACCELERATE_DISABLE_RICH" in os.environ:
																		warnings.warn(
																		    '''`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`.'''	)
																		return not parse_flag_from_env('''ACCELERATE_DISABLE_RICH'''	, snake_case	)
												return parse_flag_from_env('''ACCELERATE_ENABLE_RICH'''	, snake_case	)
						return False




def 		A_	(							) ->      Any:



						'''simple docstring'''

						return _is_package_available('''sagemaker'''	)




def 		A_	(							) ->      int:



						'''simple docstring'''

						return _is_package_available('''tqdm'''	)




def 		A_	(							) ->      Optional[int]:



						'''simple docstring'''

						return _is_package_available('''mlflow'''	)




def 		A_	(							) ->      Dict:



						'''simple docstring'''

						return is_torch_version('''>='''	, '''1.12'''	) and torch.backends.mps.is_available() and torch.backends.mps.is_built()




def 		A_	(							) ->      Tuple:



						'''simple docstring'''

						def get_major_and_minor_from_version(snake_case							:				str	):
												return str(version.parse(snake_case	).major	) + "." + str(version.parse(snake_case	).minor	)

						__UpperCamelCase       					=     importlib.metadata.version('''torch'''	)
						if importlib.util.find_spec('''intel_extension_for_pytorch'''	) is None:
												return False
						__UpperCamelCase       					=     '''N/A'''
						try:
												__UpperCamelCase       					=     importlib.metadata.version('''intel_extension_for_pytorch'''	)
						except importlib.metadata.PackageNotFoundError:
												return False
						__UpperCamelCase       					=     get_major_and_minor_from_version(_torch_version	)
						__UpperCamelCase       					=     get_major_and_minor_from_version(_ipex_version	)
						if torch_major_and_minor != ipex_major_and_minor:
												warnings.warn(
												    f"Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"
												    f" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."	)
												return False
						return True




@lru_cache
def 		A_	(							snake_case							:				Any=False	) ->      List[str]:



						'''simple docstring'''

						if importlib.util.find_spec('''torch'''	) is None or importlib.util.find_spec('''torch_npu'''	) is None:
												return False

						import torch
						import torch_npu  # noqa: F401

						if check_device:
												try:
																		# Will raise a RuntimeError if no NPU is found
																		__UpperCamelCase       					=     torch.npu.device_count()
																		return torch.npu.is_available()
												except RuntimeError:
																		return False
						return hasattr(snake_case	, '''npu'''	) and torch.npu.is_available()




@lru_cache
def 		A_	(							snake_case							:				Optional[Any]=False	) ->      int:



						'''simple docstring'''

						if not parse_flag_from_env('''ACCELERATE_USE_XPU'''	, default=snake_case	):
												return False
						if is_ipex_available():
												import torch

												if is_torch_version('''<='''	, '''1.12'''	):
																		return False
						else:
												return False

						import intel_extension_for_pytorch  # noqa: F401

						if check_device:
												try:
																		# Will raise a RuntimeError if no XPU  is found
																		__UpperCamelCase       					=     torch.xpu.device_count()
																		return torch.xpu.is_available()
												except RuntimeError:
																		return False
						return hasattr(snake_case	, '''xpu'''	) and torch.xpu.is_available()






import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
				from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

				from .test_feature_extraction_speechta import floats_list


lowercase__							:							List[Any]													=     get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")






@require_torch
class     SCREAMING_SNAKE_CASE__      (							unittest.TestCase      ):

							"""simple docstring"""






							def       A__						(					self     )->				List[Any]:





													'''simple docstring'''






													__UpperCamelCase       					=     tempfile.mkdtemp()

													__UpperCamelCase       					=     SpeechTaTokenizer(SCREAMING_SNAKE_CASE_     )
													tokenizer.save_pretrained(self.tmpdirname     )

													__UpperCamelCase       					=     {
													    '''feature_size''': 1,
													    '''padding_value''': 0.0,
													    '''sampling_rate''': 16000,
													    '''do_normalize''': False,
													    '''num_mel_bins''': 80,
													    '''hop_length''': 16,
													    '''win_length''': 64,
													    '''win_function''': '''hann_window''',
													    '''fmin''': 80,
													    '''fmax''': 7600,
													    '''mel_floor''': 1E-10,
													    '''reduction_factor''': 2,
													    '''return_attention_mask''': True,
													}

													__UpperCamelCase       					=     os.path.join(self.tmpdirname       ,		SCREAMING_SNAKE_CASE_     )
													with open(self.feature_extraction_file       ,		'''w'''       ,		encoding='''utf-8'''     ) as fp:
																			fp.write(json.dumps(SCREAMING_SNAKE_CASE_     ) + '''\n'''     )



							def       A__						(					self       ,		**SCREAMING_SNAKE_CASE_     )->				Union[str, Any]:





													'''simple docstring'''






													return SpeechTaTokenizer.from_pretrained(self.tmpdirname       ,		**SCREAMING_SNAKE_CASE_     )



							def       A__						(					self       ,		**SCREAMING_SNAKE_CASE_     )->				Union[str, Any]:





													'''simple docstring'''






													return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname       ,		**SCREAMING_SNAKE_CASE_     )



							def       A__						(					self     )->				str:





													'''simple docstring'''






													shutil.rmtree(self.tmpdirname     )



							def       A__						(					self     )->				Optional[int]:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_tokenizer()
													__UpperCamelCase       					=     self.get_feature_extractor()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													processor.save_pretrained(self.tmpdirname     )
													__UpperCamelCase       					=     SpeechTaProcessor.from_pretrained(self.tmpdirname     )

													self.assertEqual(processor.tokenizer.get_vocab()       ,		tokenizer.get_vocab()     )
													self.assertIsInstance(processor.tokenizer       ,		SCREAMING_SNAKE_CASE_     )

													self.assertEqual(processor.feature_extractor.to_json_string()       ,		feature_extractor.to_json_string()     )
													self.assertIsInstance(processor.feature_extractor       ,		SCREAMING_SNAKE_CASE_     )



							def       A__						(					self     )->				List[str]:





													'''simple docstring'''






													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=self.get_tokenizer()       ,		feature_extractor=self.get_feature_extractor()     )
													processor.save_pretrained(self.tmpdirname     )

													__UpperCamelCase       					=     self.get_tokenizer(bos_token='''(BOS)'''       ,		eos_token='''(EOS)'''     )
													__UpperCamelCase       					=     self.get_feature_extractor(do_normalize=SCREAMING_SNAKE_CASE_       ,		padding_value=1.0     )

													__UpperCamelCase       					=     SpeechTaProcessor.from_pretrained(
													    self.tmpdirname       ,		bos_token='''(BOS)'''       ,		eos_token='''(EOS)'''       ,		do_normalize=SCREAMING_SNAKE_CASE_       ,		padding_value=1.0     )

													self.assertEqual(processor.tokenizer.get_vocab()       ,		tokenizer_add_kwargs.get_vocab()     )
													self.assertIsInstance(processor.tokenizer       ,		SCREAMING_SNAKE_CASE_     )

													self.assertEqual(processor.feature_extractor.to_json_string()       ,		feature_extractor_add_kwargs.to_json_string()     )
													self.assertIsInstance(processor.feature_extractor       ,		SCREAMING_SNAKE_CASE_     )



							def       A__						(					self     )->				Dict:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     floats_list((3, 1000)     )

													__UpperCamelCase       					=     feature_extractor(audio=SCREAMING_SNAKE_CASE_       ,		return_tensors='''np'''     )
													__UpperCamelCase       					=     processor(audio=SCREAMING_SNAKE_CASE_       ,		return_tensors='''np'''     )

													for key in input_feat_extract.keys():
																			self.assertAlmostEqual(input_feat_extract[key].sum()       ,		input_processor[key].sum()       ,		delta=1E-2     )



							def       A__						(					self     )->				Dict:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     floats_list((3, 1000)     )

													__UpperCamelCase       					=     feature_extractor(audio_target=SCREAMING_SNAKE_CASE_       ,		return_tensors='''np'''     )
													__UpperCamelCase       					=     processor(audio_target=SCREAMING_SNAKE_CASE_       ,		return_tensors='''np'''     )

													for key in input_feat_extract.keys():
																			self.assertAlmostEqual(input_feat_extract[key].sum()       ,		input_processor[key].sum()       ,		delta=1E-2     )



							def       A__						(					self     )->				int:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     '''This is a test string'''

													__UpperCamelCase       					=     processor(text=SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     tokenizer(SCREAMING_SNAKE_CASE_     )

													for key in encoded_tok.keys():
																			self.assertListEqual(encoded_tok[key]       ,		encoded_processor[key]     )



							def       A__						(					self     )->				int:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     '''This is a test string'''

													__UpperCamelCase       					=     processor(text_target=SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     tokenizer(SCREAMING_SNAKE_CASE_     )

													for key in encoded_tok.keys():
																			self.assertListEqual(encoded_tok[key]       ,		encoded_processor[key]     )



							def       A__						(					self     )->				Dict:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													__UpperCamelCase       					=     processor.batch_decode(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     tokenizer.batch_decode(SCREAMING_SNAKE_CASE_     )

													self.assertListEqual(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )



							def       A__						(					self     )->				List[str]:





													'''simple docstring'''






													__UpperCamelCase       					=     self.get_feature_extractor()
													__UpperCamelCase       					=     self.get_tokenizer()

													__UpperCamelCase       					=     SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_       ,		feature_extractor=SCREAMING_SNAKE_CASE_     )

													self.assertListEqual(
													    processor.model_input_names       ,		feature_extractor.model_input_names       ,		msg='''`processor` and `feature_extractor` model input names do not match'''       ,		)




