




# 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_ 		=  '''Here is a text containing a lot of information: \'\'\'{text}\'\'\'.

Can you answer this question about the text: \'{question}\''''

class 			_lowerCamelCase    (      _SCREAMING_SNAKE_CASE ):

      """simple docstring"""

      lowerCAmelCase__      :			str     =       "google/flan-t5-base"
      lowerCAmelCase__      :			Dict     =       (
          "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__      :			Union[str, Any]     =       "text_qa"
      lowerCAmelCase__      :			Optional[Any]     =       AutoTokenizer
      lowerCAmelCase__      :			List[Any]     =       AutoModelForSeqaSeqLM

      lowerCAmelCase__      :			List[str]     =       ["text", "text"]
      lowerCAmelCase__      :			Dict     =       ["text"]







      def    snake_case						(  self       :			Dict			,							snake_case       :			List[str]			,							snake_case       :			List[Any]					):
          __UpperCamelCase			=    QA_PROMPT.format(text=UpperCAmelCase_			,							question=UpperCAmelCase_					)
          return self.pre_processor(UpperCAmelCase_			,							return_tensors='''pt'''					)







      def    snake_case						(  self       :			int			,							snake_case       :			Any					):
          __UpperCamelCase			=    self.model.generate(**UpperCAmelCase_					)

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

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







      def    snake_case						(  self       :			Optional[Any]			,							snake_case       :			List[str]					):
          return self.pre_processor.decode(UpperCAmelCase_			,							skip_special_tokens=UpperCAmelCase_			,							clean_up_tokenization_spaces=UpperCAmelCase_					)













from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase__    :      int       					={
    '''configuration_flaubert''': ['''FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FlaubertConfig''', '''FlaubertOnnxConfig'''],
    '''tokenization_flaubert''': ['''FlaubertTokenizer'''],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__    :      int       					=[
							    '''FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''FlaubertForMultipleChoice''',
							    '''FlaubertForQuestionAnswering''',
							    '''FlaubertForQuestionAnsweringSimple''',
							    '''FlaubertForSequenceClassification''',
							    '''FlaubertForTokenClassification''',
							    '''FlaubertModel''',
							    '''FlaubertWithLMHeadModel''',
							    '''FlaubertPreTrainedModel''',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__    :      List[str]       					=[
							    '''TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''TFFlaubertForMultipleChoice''',
							    '''TFFlaubertForQuestionAnsweringSimple''',
							    '''TFFlaubertForSequenceClassification''',
							    '''TFFlaubertForTokenClassification''',
							    '''TFFlaubertModel''',
							    '''TFFlaubertPreTrainedModel''',
							    '''TFFlaubertWithLMHeadModel''',
							]


if TYPE_CHECKING:
							from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
							from .tokenization_flaubert import FlaubertTokenizer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flaubert import (
														    FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    FlaubertForMultipleChoice,
														    FlaubertForQuestionAnswering,
														    FlaubertForQuestionAnsweringSimple,
														    FlaubertForSequenceClassification,
														    FlaubertForTokenClassification,
														    FlaubertModel,
														    FlaubertPreTrainedModel,
														    FlaubertWithLMHeadModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_flaubert import (
														    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFFlaubertForMultipleChoice,
														    TFFlaubertForQuestionAnsweringSimple,
														    TFFlaubertForSequenceClassification,
														    TFFlaubertForTokenClassification,
														    TFFlaubertModel,
														    TFFlaubertPreTrainedModel,
														    TFFlaubertWithLMHeadModel,
														)

else:
							import sys

							UpperCAmelCase__    :      List[Any]       					=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





