






'''simple docstring'''
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


__lowerCAmelCase							=get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")


@require_torch
class    _snake_case   (				unittest.TestCase					):

					"""simple docstring"""





					def  __SCREAMING_SNAKE_CASE (     self     )      ->	Tuple:
										a_									=   tempfile.mkdtemp()

										a_									=   SpeechTaTokenizer(UpperCAmelCase__     )
										tokenizer.save_pretrained(self.tmpdirname     )

										a_									=   {
										    'feature_size': 1,
										    'padding_value': 0.0,
										    'sampling_rate': 1_6000,
										    '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,
										}

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




					def  __SCREAMING_SNAKE_CASE (     self   , **UpperCAmelCase__     )      ->	Union[str, Any]:
										return SpeechTaTokenizer.from_pretrained(self.tmpdirname   , **UpperCAmelCase__     )




					def  __SCREAMING_SNAKE_CASE (     self   , **UpperCAmelCase__     )      ->	Optional[int]:
										return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname   , **UpperCAmelCase__     )




					def  __SCREAMING_SNAKE_CASE (     self     )      ->	List[Any]:
										shutil.rmtree(self.tmpdirname     )




					def  __SCREAMING_SNAKE_CASE (     self     )      ->	List[Any]:
										a_									=   self.get_tokenizer()
										a_									=   self.get_feature_extractor()

										a_									=   SpeechTaProcessor(tokenizer=UpperCAmelCase__   , feature_extractor=UpperCAmelCase__     )

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

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

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




					def  __SCREAMING_SNAKE_CASE (     self     )      ->	List[Any]:
										a_									=   SpeechTaProcessor(tokenizer=self.get_tokenizer()   , feature_extractor=self.get_feature_extractor()     )
										processor.save_pretrained(self.tmpdirname     )

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

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

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

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




					def  __SCREAMING_SNAKE_CASE (     self     )      ->	str:
										a_									=   self.get_feature_extractor()
										a_									=   self.get_tokenizer()

										a_									=   SpeechTaProcessor(tokenizer=UpperCAmelCase__   , feature_extractor=UpperCAmelCase__     )

										a_									=   floats_list((3, 1000)     )

										a_									=   feature_extractor(audio=UpperCAmelCase__   , return_tensors='np'     )
										a_									=   processor(audio=UpperCAmelCase__   , 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  __SCREAMING_SNAKE_CASE (     self     )      ->	Optional[int]:
										a_									=   self.get_feature_extractor()
										a_									=   self.get_tokenizer()

										a_									=   SpeechTaProcessor(tokenizer=UpperCAmelCase__   , feature_extractor=UpperCAmelCase__     )

										a_									=   floats_list((3, 1000)     )

										a_									=   feature_extractor(audio_target=UpperCAmelCase__   , return_tensors='np'     )
										a_									=   processor(audio_target=UpperCAmelCase__   , 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  __SCREAMING_SNAKE_CASE (     self     )      ->	str:
										a_									=   self.get_feature_extractor()
										a_									=   self.get_tokenizer()

										a_									=   SpeechTaProcessor(tokenizer=UpperCAmelCase__   , feature_extractor=UpperCAmelCase__     )

										a_									=   'This is a test string'

										a_									=   processor(text=UpperCAmelCase__     )
										a_									=   tokenizer(UpperCAmelCase__     )

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




					def  __SCREAMING_SNAKE_CASE (     self     )      ->	int:
										a_									=   self.get_feature_extractor()
										a_									=   self.get_tokenizer()

										a_									=   SpeechTaProcessor(tokenizer=UpperCAmelCase__   , feature_extractor=UpperCAmelCase__     )

										a_									=   'This is a test string'

										a_									=   processor(text_target=UpperCAmelCase__     )
										a_									=   tokenizer(UpperCAmelCase__     )

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




					def  __SCREAMING_SNAKE_CASE (     self     )      ->	Optional[Any]:
										a_									=   self.get_feature_extractor()
										a_									=   self.get_tokenizer()

										a_									=   SpeechTaProcessor(tokenizer=UpperCAmelCase__   , feature_extractor=UpperCAmelCase__     )

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

										a_									=   processor.batch_decode(UpperCAmelCase__     )
										a_									=   tokenizer.batch_decode(UpperCAmelCase__     )

										self.assertListEqual(UpperCAmelCase__   , UpperCAmelCase__     )




					def  __SCREAMING_SNAKE_CASE (     self     )      ->	List[Any]:
										a_									=   self.get_feature_extractor()
										a_									=   self.get_tokenizer()

										a_									=   SpeechTaProcessor(tokenizer=UpperCAmelCase__   , feature_extractor=UpperCAmelCase__     )

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









'''simple docstring'''
def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase					,  _UpperCAmelCase )				->				list[int]:






					"""simple docstring"""







					if hue < 0 or hue > 3_6_0:
										raise Exception('hue should be between 0 and 360' )

					if saturation < 0 or saturation > 1:
										raise Exception('saturation should be between 0 and 1' )

					if value < 0 or value > 1:
										raise Exception('value should be between 0 and 1' )

					a_									=   value * saturation
					a_									=   hue / 6_0
					a_									=   chroma * (1 - abs(hue_section % 2 - 1 ))
					a_									=   value - chroma

					if hue_section >= 0 and hue_section <= 1:
										a_									=   round(2_5_5 * (chroma + match_value) )
										a_									=   round(2_5_5 * (second_largest_component + match_value) )
										a_									=   round(2_5_5 * (match_value) )
					elif hue_section > 1 and hue_section <= 2:
										a_									=   round(2_5_5 * (second_largest_component + match_value) )
										a_									=   round(2_5_5 * (chroma + match_value) )
										a_									=   round(2_5_5 * (match_value) )
					elif hue_section > 2 and hue_section <= 3:
										a_									=   round(2_5_5 * (match_value) )
										a_									=   round(2_5_5 * (chroma + match_value) )
										a_									=   round(2_5_5 * (second_largest_component + match_value) )
					elif hue_section > 3 and hue_section <= 4:
										a_									=   round(2_5_5 * (match_value) )
										a_									=   round(2_5_5 * (second_largest_component + match_value) )
										a_									=   round(2_5_5 * (chroma + match_value) )
					elif hue_section > 4 and hue_section <= 5:
										a_									=   round(2_5_5 * (second_largest_component + match_value) )
										a_									=   round(2_5_5 * (match_value) )
										a_									=   round(2_5_5 * (chroma + match_value) )
					else:
										a_									=   round(2_5_5 * (chroma + match_value) )
										a_									=   round(2_5_5 * (match_value) )
										a_									=   round(2_5_5 * (second_largest_component + match_value) )

					return [red, green, blue]

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase					,  _UpperCAmelCase )				->				list[float]:






					"""simple docstring"""







					if red < 0 or red > 2_5_5:
										raise Exception('red should be between 0 and 255' )

					if green < 0 or green > 2_5_5:
										raise Exception('green should be between 0 and 255' )

					if blue < 0 or blue > 2_5_5:
										raise Exception('blue should be between 0 and 255' )

					a_									=   red / 2_5_5
					a_									=   green / 2_5_5
					a_									=   blue / 2_5_5
					a_									=   max(_UpperCAmelCase					,  _UpperCAmelCase					,  _UpperCAmelCase )
					a_									=   value - min(_UpperCAmelCase					,  _UpperCAmelCase					,  _UpperCAmelCase )
					a_									=   0 if value == 0 else chroma / value

					if chroma == 0:
										a_									=   0.0
					elif value == float_red:
										a_									=   6_0 * (0 + (float_green - float_blue) / chroma)
					elif value == float_green:
										a_									=   6_0 * (2 + (float_blue - float_red) / chroma)
					else:
										a_									=   6_0 * (4 + (float_red - float_green) / chroma)

					a_									=   (hue + 3_6_0) % 3_6_0

					return [hue, saturation, value]





def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase )				->				bool:






					"""simple docstring"""







					a_									=   abs(hsv_a[0] - hsv_a[0] ) < 0.2
					a_									=   abs(hsv_a[1] - hsv_a[1] ) < 0.0_0_2
					a_									=   abs(hsv_a[2] - hsv_a[2] ) < 0.0_0_2

					return check_hue and check_saturation and check_value

