





# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


a__			:    Dict			      =		'Here is a text containing a lot of information: \'\'\'{text}\'\'\'.\n\nCan you answer this question about the text: \'{question}\''





class UpperCAmelCase_							(   _SCREAMING_SNAKE_CASE   ):
  __lowerCAmelCase      :	str  	=      """google/flan-t5-base"""
  __lowerCAmelCase      :	List[Any]  	=      (
      """This is a tool that answers questions related to a text. It takes two arguments named `text`, which is the """
      """text where to find the answer, and `question`, which is the question, and returns the answer to the question."""
  )
  __lowerCAmelCase      :	Tuple  	=      """text_qa"""
  __lowerCAmelCase      :	int  	=      AutoTokenizer
  __lowerCAmelCase      :	Optional[int]  	=      AutoModelForSeqaSeqLM

  __lowerCAmelCase      :	Union[str, Any]  	=      ["""text""", """text"""]
  __lowerCAmelCase      :	Tuple  	=      ["""text"""]


  def 	__UpperCAmelCase    (       self   ,__snake_case   ,__snake_case   ):



       """simple docstring"""





       A_					      =					QA_PROMPT.format(text=__snake_case   ,question=__snake_case   )
       return self.pre_processor(__snake_case   ,return_tensors='''pt'''   )


  def 	__UpperCAmelCase    (       self   ,__snake_case   ):



       """simple docstring"""





       A_					      =					self.model.generate(**__snake_case   )

       A_      ,						A_					      =					inputs['''input_ids'''].shape
       A_					      =					output_ids.shape[0]

       return output_ids.reshape(__snake_case   ,out_b // in_b   ,*output_ids.shape[1:]   )[0][0]




  def 	__UpperCAmelCase    (       self   ,__snake_case   ):



       """simple docstring"""





       return self.pre_processor.decode(__snake_case   ,skip_special_tokens=__snake_case   ,clean_up_tokenization_spaces=__snake_case   )










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__			:    Optional[Any]			      =		get_tests_dir('fixtures/test_sentencepiece.model')





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


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					tempfile.mkdtemp()

       A_					      =					['''<s>''', '''<pad>''', '''</s>''', '''<unk>''', '''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']
       A_					      =					dict(zip(__snake_case   ,range(len(__snake_case   )   )   )   )
       A_					      =					Path(self.tmpdirname   )
       save_json(__snake_case   ,save_dir / VOCAB_FILES_NAMES['''vocab_file''']   )
       if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
            copyfile(__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(__snake_case   ,save_dir / FEATURE_EXTRACTOR_NAME   )


  def 	__UpperCAmelCase    (       self   ,**__snake_case   ):



       """simple docstring"""





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


  def 	__UpperCAmelCase    (       self   ,**__snake_case   ):



       """simple docstring"""





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


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       shutil.rmtree(self.tmpdirname   )


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_tokenizer()
       A_					      =					self.get_feature_extractor()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__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   ,__snake_case   )

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


  def 	__UpperCAmelCase    (       self   ):



       """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=__snake_case   ,padding_value=1.0   )

       A_					      =					SpeechaTextProcessor.from_pretrained(
           self.tmpdirname   ,bos_token='''(BOS)'''   ,eos_token='''(EOS)'''   ,do_normalize=__snake_case   ,padding_value=1.0   )

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

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


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_feature_extractor()
       A_					      =					self.get_tokenizer()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

       A_					      =					floats_list((3, 1_0_0_0)   )

       A_					      =					feature_extractor(__snake_case   ,return_tensors='''np'''   )
       A_					      =					processor(__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 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_feature_extractor()
       A_					      =					self.get_tokenizer()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

       A_					      =					'''This is a test string'''

       A_					      =					processor(text=__snake_case   )

       A_					      =					tokenizer(__snake_case   )

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


  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_feature_extractor()
       A_					      =					self.get_tokenizer()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

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

       A_					      =					processor.batch_decode(__snake_case   )
       A_					      =					tokenizer.batch_decode(__snake_case   )

       self.assertListEqual(__snake_case   ,__snake_case   )




  def 	__UpperCAmelCase    (       self   ):



       """simple docstring"""





       A_					      =					self.get_feature_extractor()
       A_					      =					self.get_tokenizer()

       A_					      =					SpeechaTextProcessor(tokenizer=__snake_case   ,feature_extractor=__snake_case   )

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



