



"""simple docstring"""


# 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


snake_case_								=			"""Here is a text containing a lot of information: '''{text}'''.

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







class  A_     (	SCREAMING_SNAKE_CASE_							):



						"""simple docstring"""
						__UpperCamelCase													=				"""google/flan-t5-base"""
						__UpperCamelCase													=				(
						    """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."""
						)
						__UpperCamelCase													=				"""text_qa"""
						__UpperCamelCase													=				AutoTokenizer
						__UpperCamelCase													=				AutoModelForSeqaSeqLM

						__UpperCamelCase													=				["""text""", """text"""]
						__UpperCamelCase													=				["""text"""]






						def       UpperCAmelCase__	(   self					:Tuple  ,    lowercase_					:str  ,    lowercase_					:str   )							->     Dict:
												UpperCAmelCase			 =					QA_PROMPT.format(text=lowercase_  ,    question=lowercase_   )
												return self.pre_processor(lowercase_  ,    return_tensors='pt'   )






						def       UpperCAmelCase__	(   self					:Any  ,    lowercase_					:Any   )							->     Any:
												UpperCAmelCase			 =					self.model.generate(**lowercase_   )

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

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






						def       UpperCAmelCase__	(   self					:Union[str, Any]  ,    lowercase_					:Tuple   )							->     Optional[Any]:
												return self.pre_processor.decode(lowercase_  ,    skip_special_tokens=lowercase_  ,    clean_up_tokenization_spaces=lowercase_   )






import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding







class      SCREAMING_SNAKE_CASE__					(  __UpperCamelCase    ):
       A							:	Optional[Any]          =	["image_processor", "tokenizer"]
       A							:	Dict          =	"VideoMAEImageProcessor"
       A							:	Tuple          =	("CLIPTokenizer", "CLIPTokenizerFast")

       def __init__(							self					:     str			,			_lowerCAmelCase					:     Tuple=None			,			_lowerCAmelCase					:     Any=None			,			**_lowerCAmelCase					:     Union[str, Any]			):
           __snake_case       :				int 			=    None
           if "feature_extractor" in kwargs:
               warnings.warn(
                   """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
                   """ instead."""			,			_lowerCAmelCase			,			)
               __snake_case       :				Optional[Any] 			=    kwargs.pop("""feature_extractor"""			)

           __snake_case       :				int 			=    image_processor if image_processor is not None else feature_extractor
           if image_processor is None:
               raise ValueError("""You need to specify an `image_processor`."""			)
           if tokenizer is None:
               raise ValueError("""You need to specify a `tokenizer`."""			)

           super().__init__(_lowerCAmelCase			,			_lowerCAmelCase			)
           __snake_case       :				Optional[Any] 			=    self.image_processor

       def __call__(							self					:     str			,			_lowerCAmelCase					:     int=None			,			_lowerCAmelCase					:     Dict=None			,			_lowerCAmelCase					:     Optional[int]=None			,			**_lowerCAmelCase					:     List[str]			):

           if text is None and videos is None:
               raise ValueError("""You have to specify either text or videos. Both cannot be none."""			)

           if text is not None:
               __snake_case       :				Optional[Any] 			=    self.tokenizer(_lowerCAmelCase			,			return_tensors=_lowerCAmelCase			,			**_lowerCAmelCase			)

           if videos is not None:
               __snake_case       :				Optional[int] 			=    self.image_processor(_lowerCAmelCase			,			return_tensors=_lowerCAmelCase			,			**_lowerCAmelCase			)

           if text is not None and videos is not None:
               __snake_case       :				Union[str, Any] 			=    image_features.pixel_values
               return encoding
           elif text is not None:
               return encoding
           else:
               return BatchEncoding(data=dict(**_lowerCAmelCase			)			,			tensor_type=_lowerCAmelCase			)

       def 			snake_case__    (							self					:     Tuple			,			*_lowerCAmelCase					:     str			,			**_lowerCAmelCase					:     List[Any]			):
           return self.tokenizer.batch_decode(*_lowerCAmelCase			,			**_lowerCAmelCase			)

       def 			snake_case__    (							self					:     Tuple			,			*_lowerCAmelCase					:     List[Any]			,			**_lowerCAmelCase					:     Dict			):
           return self.tokenizer.decode(*_lowerCAmelCase			,			**_lowerCAmelCase			)

       @property
       def 			snake_case__    (							self					:     str			):
           return ["input_ids", "attention_mask", "position_ids", "pixel_values"]

       @property
       def 			snake_case__    (							self					:     str			):
           warnings.warn(
               """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""			,			_lowerCAmelCase			,			)
           return self.image_processor_class





       @property
       def 			snake_case__    (							self					:     Union[str, Any]			):
           warnings.warn(
               """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""			,			_lowerCAmelCase			,			)
           return self.image_processor



