




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


UpperCamelCase__						=		get_tests_dir('fixtures/test_sentencepiece_bpe_char.model')


@require_torch
class 							__SCREAMING_SNAKE_CASE				(						unittest.TestCase    ):

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				tempfile.mkdtemp()

						lowerCamelCase_				:						Tuple				  =				SpeechTaTokenizer(__lowercase   )
						tokenizer.save_pretrained(self.tmpdirname   )

						lowerCamelCase_				:						Tuple				  =				{
						    'feature_size': 1,
						    'padding_value': 0.0,
						    'sampling_rate': 16_000,
						    'do_normalize': False,
						    'num_mel_bins': 80,
						    'hop_length': 16,
						    'win_length': 64,
						    'win_function': 'hann_window',
						    'fmin': 80,
						    'fmax': 7_600,
						    'mel_floor': 1E-10,
						    'reduction_factor': 2,
						    'return_attention_mask': True,
						}

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

					def       lowercase_				(							self					,			**__lowercase   ):







						'''simple docstring'''




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

					def       lowercase_				(							self					,			**__lowercase   ):







						'''simple docstring'''




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

					def       lowercase_				(							self   ):







						'''simple docstring'''




						shutil.rmtree(self.tmpdirname   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Optional[Any]				  =				self.get_tokenizer()
						lowerCamelCase_				:						Tuple				  =				self.get_feature_extractor()

						lowerCamelCase_				:						Dict				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						processor.save_pretrained(self.tmpdirname   )
						lowerCamelCase_				:						int				  =				SpeechTaProcessor.from_pretrained(self.tmpdirname   )

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

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

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						str				  =				SpeechTaProcessor(tokenizer=self.get_tokenizer()					,			feature_extractor=self.get_feature_extractor()   )
						processor.save_pretrained(self.tmpdirname   )

						lowerCamelCase_				:						Any				  =				self.get_tokenizer(bos_token='(BOS)'					,			eos_token='(EOS)'   )
						lowerCamelCase_				:						Optional[Any]				  =				self.get_feature_extractor(do_normalize=__lowercase					,			padding_value=1.0   )

						lowerCamelCase_				:						Tuple				  =				SpeechTaProcessor.from_pretrained(
						    self.tmpdirname					,			bos_token='(BOS)'					,			eos_token='(EOS)'					,			do_normalize=__lowercase					,			padding_value=1.0   )

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

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

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[str]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						Optional[Any]				  =				self.get_tokenizer()

						lowerCamelCase_				:						Any				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						Dict				  =				floats_list((3, 1_000)   )

						lowerCamelCase_				:						Optional[Any]				  =				feature_extractor(audio=__lowercase					,			return_tensors='np'   )
						lowerCamelCase_				:						Optional[int]				  =				processor(audio=__lowercase					,			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       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						List[str]				  =				self.get_tokenizer()

						lowerCamelCase_				:						Any				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						str				  =				floats_list((3, 1_000)   )

						lowerCamelCase_				:						str				  =				feature_extractor(audio_target=__lowercase					,			return_tensors='np'   )
						lowerCamelCase_				:						Union[str, Any]				  =				processor(audio_target=__lowercase					,			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       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Optional[int]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						int				  =				self.get_tokenizer()

						lowerCamelCase_				:						Union[str, Any]				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						Optional[int]				  =				'This is a test string'

						lowerCamelCase_				:						List[Any]				  =				processor(text=__lowercase   )
						lowerCamelCase_				:						int				  =				tokenizer(__lowercase   )

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

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Optional[int]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						Optional[Any]				  =				self.get_tokenizer()

						lowerCamelCase_				:						Optional[Any]				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						str				  =				'This is a test string'

						lowerCamelCase_				:						List[Any]				  =				processor(text_target=__lowercase   )
						lowerCamelCase_				:						int				  =				tokenizer(__lowercase   )

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

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Dict				  =				self.get_feature_extractor()
						lowerCamelCase_				:						Any				  =				self.get_tokenizer()

						lowerCamelCase_				:						Any				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						Union[str, Any]				  =				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

						lowerCamelCase_				:						Dict				  =				processor.batch_decode(__lowercase   )
						lowerCamelCase_				:						List[Any]				  =				tokenizer.batch_decode(__lowercase   )

						self.assertListEqual(__lowercase					,			__lowercase   )





					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						str				  =				self.get_tokenizer()

						lowerCamelCase_				:						List[Any]				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

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








import json

import requests

from .fetch_github_info import AUTHENTICATED_USER_ENDPOINT, fetch_github_info
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    class        snake_case_				:







       """simple docstring"""



       def __init__(     self:						Tuple ,							snake_case__:						Optional[int]						)	->		None:


           """simple docstring"""



           assert isinstance(snake_case__ ,							(bytes, str)						)
           _lowercase     			=						content

       def       SCREAMING_SNAKE_CASE__					(     self:						Tuple						)	->		str:


           """simple docstring"""



           return json.loads(self.content						)

    def mock_response(*_lowercase,   **_lowercase   ):
        assert args[0] == AUTHENTICATED_USER_ENDPOINT
        assert "Authorization" in kwargs["headers"]
        assert kwargs["headers"]["Authorization"].startswith('token '   )
        assert "Accept" in kwargs["headers"]
        return FakeResponse(b'{"login":"test","id":1}'   )

    monkeypatch.setattr(_lowercase,   'get',   _lowercase   )
    _lowercase     			=						fetch_github_info('token'   )
    assert result["login"] == "test"
    assert result["id"] == 1
