
"""simple docstring"""




import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
    from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


a		:					Any    	=					get_tests_dir('fixtures/test_sentencepiece.model')







@require_torch
@require_torchaudio
@require_sentencepiece
class 						lowercase(unittest.TestCase					):



     def  lowercase__     (       self      )		->    Any:







         """simple docstring"""



         a__    = tempfile.mkdtemp()

         a__    = ['<s>', '<pad>', '</s>', '<unk>', '▁This', '▁is', '▁a', '▁t', 'est']
         a__    = dict(zip(__SCREAMING_SNAKE_CASE    ,							range(len(__SCREAMING_SNAKE_CASE      )      )      )      )
         a__    = Path(self.tmpdirname      )
         save_json(__SCREAMING_SNAKE_CASE    ,							save_dir / VOCAB_FILES_NAMES['vocab_file']      )
         if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
             copyfile(__SCREAMING_SNAKE_CASE    ,							save_dir / VOCAB_FILES_NAMES['spm_file']      )

         a__    = SpeechaTextTokenizer.from_pretrained(self.tmpdirname      )
         tokenizer.save_pretrained(self.tmpdirname      )

         a__    = {
             'feature_size': 2_4,
             'num_mel_bins': 2_4,
             'padding_value': 0.0,
             'sampling_rate': 1_6_0_0_0,
             'return_attention_mask': False,
             'do_normalize': True,
         }
         save_json(__SCREAMING_SNAKE_CASE    ,							save_dir / FEATURE_EXTRACTOR_NAME      )



     def  lowercase__     (       self    ,							**__SCREAMING_SNAKE_CASE      )		->    Union[str, Any]:







         """simple docstring"""



         return SpeechaTextTokenizer.from_pretrained(self.tmpdirname    ,							**__SCREAMING_SNAKE_CASE      )



     def  lowercase__     (       self    ,							**__SCREAMING_SNAKE_CASE      )		->    str:







         """simple docstring"""



         return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname    ,							**__SCREAMING_SNAKE_CASE      )



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







         """simple docstring"""



         shutil.rmtree(self.tmpdirname      )



     def  lowercase__     (       self      )		->    int:







         """simple docstring"""



         a__    = self.get_tokenizer()
         a__    = self.get_feature_extractor()

         a__    = SpeechaTextProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,							feature_extractor=__SCREAMING_SNAKE_CASE      )

         processor.save_pretrained(self.tmpdirname      )
         a__    = SpeechaTextProcessor.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  lowercase__     (       self      )		->    Union[str, Any]:







         """simple docstring"""



         a__    = SpeechaTextProcessor(
             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=__SCREAMING_SNAKE_CASE    ,							padding_value=1.0      )

         a__    = SpeechaTextProcessor.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  lowercase__     (       self      )		->    str:







         """simple docstring"""



         a__    = self.get_feature_extractor()
         a__    = self.get_tokenizer()

         a__    = SpeechaTextProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,							feature_extractor=__SCREAMING_SNAKE_CASE      )

         a__    = floats_list((3, 1_0_0_0)      )

         a__    = feature_extractor(__SCREAMING_SNAKE_CASE    ,							return_tensors='np'      )
         a__    = processor(__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  lowercase__     (       self      )		->    Any:







         """simple docstring"""



         a__    = self.get_feature_extractor()
         a__    = self.get_tokenizer()

         a__    = SpeechaTextProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,							feature_extractor=__SCREAMING_SNAKE_CASE      )

         a__    = 'This is a test string'

         a__    = processor(text=__SCREAMING_SNAKE_CASE      )

         a__    = tokenizer(__SCREAMING_SNAKE_CASE      )

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



     def  lowercase__     (       self      )		->    str:







         """simple docstring"""



         a__    = self.get_feature_extractor()
         a__    = self.get_tokenizer()

         a__    = SpeechaTextProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,							feature_extractor=__SCREAMING_SNAKE_CASE      )

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

         a__    = processor.batch_decode(__SCREAMING_SNAKE_CASE      )
         a__    = tokenizer.batch_decode(__SCREAMING_SNAKE_CASE      )

         self.assertListEqual(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE      )




     def  lowercase__     (       self      )		->    Optional[Any]:







         """simple docstring"""



         a__    = self.get_feature_extractor()
         a__    = self.get_tokenizer()

         a__    = SpeechaTextProcessor(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'    ,							)




"""simple docstring"""




import shutil

import requests



def 						__magic_name__		(				UpperCamelCase    :		str       ,		UpperCamelCase    :		bool = False       ,		UpperCamelCase    :		str = "."    )    ->	dict:
    a__    = 'https://api.nasa.gov/planetary/apod'
    return requests.get(UpperCamelCase       ,		params={'api_key': api_key}    ).json()



def 						__magic_name__		(				UpperCamelCase    :		str       ,		UpperCamelCase    :		str = "."    )    ->	dict:
    a__    = get_apod_data(UpperCamelCase    )
    a__    = apod_data['url']
    a__    = img_url.split('/'    )[-1]
    a__    = requests.get(UpperCamelCase       ,		stream=UpperCamelCase    )

    with open(f'{path}/{img_name}'       ,		'wb+'    ) as img_file:
        shutil.copyfileobj(response.raw       ,		UpperCamelCase    )
    del response
    return apod_data



def 						__magic_name__		(				UpperCamelCase    :		str    )    ->	dict:
    a__    = 'https://images-api.nasa.gov/search'
    return requests.get(UpperCamelCase       ,		params={'q': query}    ).json()


if __name__ == "__main__":
    print(save_apod('YOUR API KEY'))
    a		:					List[Any]    	=					get_archive_data('apollo 2011')['collection']['items']
    print(apollo_aaaa_items[0]['data'][0]['description'])


