




'''simple docstring'''



from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
      from PIL import Image

      from ..image_utils import load_image

if is_tf_available():
      from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING

if is_torch_available():
      import torch

      from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING

UpperCamelCase_    	=				logging.get_logger(__name__)






@add_end_docstrings(_a )
class 							_a				(			_a ):





       '''simple docstring'''






       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             super().__init__(*A,							**A  )
             requires_backends(self,							'vision'  )
             self.check_model_type(
                 TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == 'tf' else MODEL_FOR_VISION_2_SEQ_MAPPING  )







       def        UpperCamelCase_							(      self,							A=None,							A=None,							A=None  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						{}
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						{}

             if prompt is not None:
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						prompt

             if generate_kwargs is not None:
                   SCREAMING_SNAKE_CASE   :      Dict    					=						generate_kwargs
             if max_new_tokens is not None:
                   if "generate_kwargs" not in forward_kwargs:
                         SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						{}
                   if "max_new_tokens" in forward_kwargs["generate_kwargs"]:
                         raise ValueError(
                             '\'max_new_tokens\' is defined twice, once in \'generate_kwargs\' and once as a direct parameter,'
                             ' please use only one'  )
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						max_new_tokens
             return preprocess_params, forward_kwargs, {}







       def __call__(      self,							A,							**A  ):







             '''simple docstring'''







             return super().__call__(A,							**A  )







       def        UpperCamelCase_							(      self,							A,							A=None  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						load_image(A  )

             if prompt is not None:
                   if not isinstance(A,							A  ):
                         raise ValueError(
                             F"Received an invalid text input, got - {type(A  )} - but expected a single string. "
                             'Note also that one single text can be provided for conditional image to text generation.'  )

                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						self.model.config.model_type

                   if model_type == "git":
                         SCREAMING_SNAKE_CASE   :      int    					=						self.image_processor(images=A,							return_tensors=self.framework  )
                         SCREAMING_SNAKE_CASE   :      List[str]    					=						self.tokenizer(text=A,							add_special_tokens=A  ).input_ids
                         SCREAMING_SNAKE_CASE   :      List[str]    					=						[self.tokenizer.cls_token_id] + input_ids
                         SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						torch.tensor(A  ).unsqueeze(0  )
                         model_inputs.update({'input_ids': input_ids}  )

                   elif model_type == "pix2struct":
                         SCREAMING_SNAKE_CASE   :      Optional[int]    					=						self.image_processor(images=A,							header_text=A,							return_tensors=self.framework  )

                   elif model_type != "vision-encoder-decoder":
                         # vision-encoder-decoder does not support conditional generation
                         SCREAMING_SNAKE_CASE   :      Tuple    					=						self.image_processor(images=A,							return_tensors=self.framework  )
                         SCREAMING_SNAKE_CASE   :      List[str]    					=						self.tokenizer(A,							return_tensors=self.framework  )
                         model_inputs.update(A  )

                   else:
                         raise ValueError(F"Model type {model_type} does not support conditional text generation"  )

             else:
                   SCREAMING_SNAKE_CASE   :      str    					=						self.image_processor(images=A,							return_tensors=self.framework  )

             if self.model.config.model_type == "git" and prompt is None:
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						None

             return model_inputs







       def        UpperCamelCase_							(      self,							A,							A=None  ):







             '''simple docstring'''







             if (
                 "input_ids" in model_inputs
                 and isinstance(model_inputs['input_ids'],							A  )
                 and all(x is None for x in model_inputs['input_ids']  )
             ):
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						None

             if generate_kwargs is None:
                   SCREAMING_SNAKE_CASE   :      Any    					=						{}
             # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py`
             #  parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas
             #  the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name`
             #  in the `_prepare_model_inputs` method.
             SCREAMING_SNAKE_CASE   :      Tuple    					=						model_inputs.pop(self.model.main_input_name  )
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						self.model.generate(A,							**A,							**A  )
             return model_outputs







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[Any]    					=						[]
             for output_ids in model_outputs:
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						{
                       'generated_text': self.tokenizer.decode(
                           A,							skip_special_tokens=A,							)
                   }
                   records.append(A  )
             return records






from __future__ import annotations



def 							UpperCamelCase_( lowerCamelCase_					)       ->		float:
    if not nums:
        raise ValueError('List is empty'					)
    return sum(lowerCamelCase_					) / len(lowerCamelCase_					)


if __name__ == "__main__":
 import doctest

 doctest.testmod()


