


'''simple docstring'''






from collections import UserDict
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_torch_available():
 from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING

if is_tf_available():
 from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
 from ..tf_utils import stable_softmax

lowercase							=logging.get_logger(__name__)






@add_end_docstrings(lowerCAmelCase    )
class  __magic_name__							(		lowerCAmelCase    ):






       def __init__(      self  ,							**snake_case)						->  Optional[int]:




          '''simple docstring'''
          super().__init__(**snake_case)

          requires_backends(self  ,							'vision')
          self.check_model_type(
              TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
              if self.framework == 'tf'
              else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING)






       def __call__(      self  ,							snake_case  ,							**snake_case)						->  str:




          '''simple docstring'''
          return super().__call__(snake_case  ,							**snake_case)






       def       lowerCAmelCase		(      self  ,							**snake_case)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   ={}
          if "candidate_labels" in kwargs:
             _UpperCAmelCase       :       Union[str, Any]							   =kwargs['candidate_labels']
          if "hypothesis_template" in kwargs:
             _UpperCAmelCase       :       List[Any]							   =kwargs['hypothesis_template']

          return preprocess_params, {}, {}






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case=None  ,							snake_case="This is a photo of {}.")						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =load_image(snake_case)
          _UpperCAmelCase       :       Union[str, Any]							   =self.image_processor(images=[image]  ,							return_tensors=self.framework)
          _UpperCAmelCase       :       Union[str, Any]							   =candidate_labels
          _UpperCAmelCase       :       List[Any]							   =[hypothesis_template.format(snake_case) for x in candidate_labels]
          _UpperCAmelCase       :       str							   =self.tokenizer(snake_case  ,							return_tensors=self.framework  ,							padding=snake_case)
          _UpperCAmelCase       :       Any							   =[text_inputs]
          return inputs






       def       lowerCAmelCase		(      self  ,							snake_case)						->  str:




          '''simple docstring'''
          _UpperCAmelCase       :       List[str]							   =model_inputs.pop('candidate_labels')
          _UpperCAmelCase       :       Tuple							   =model_inputs.pop('text_inputs')
          if isinstance(text_inputs[0]  ,							snake_case):
             _UpperCAmelCase       :       Any							   =text_inputs[0]
          else:
             # Batching case.
             _UpperCAmelCase       :       str							   =text_inputs[0][0]

          _UpperCAmelCase       :       Any							   =self.model(**snake_case  ,							**snake_case)

          _UpperCAmelCase       :       List[str]							   ={
              'candidate_labels': candidate_labels,
              'logits': outputs.logits_per_image,
          }
          return model_outputs






       def       lowerCAmelCase		(      self  ,							snake_case)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =model_outputs.pop('candidate_labels')
          _UpperCAmelCase       :       Union[str, Any]							   =model_outputs['logits'][0]
          if self.framework == "pt":
             _UpperCAmelCase       :       Dict							   =logits.softmax(dim=-1).squeeze(-1)
             _UpperCAmelCase       :       Union[str, Any]							   =probs.tolist()
             if not isinstance(snake_case  ,							snake_case):
                _UpperCAmelCase       :       Union[str, Any]							   =[scores]
          elif self.framework == "tf":
             _UpperCAmelCase       :       Dict							   =stable_softmax(snake_case  ,							axis=-1)
             _UpperCAmelCase       :       str							   =probs.numpy().tolist()
          else:
             raise ValueError(f"Unsupported framework: {self.framework}")

          _UpperCAmelCase       :       List[str]							   =[
              {'score': score, 'label': candidate_label}
              for score, candidate_label in sorted(zip(snake_case  ,							snake_case)  ,							key=lambda snake_case: -x[0])
          ]
          return result





'''simple docstring'''






import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import is_speech_available, is_vision_available
from transformers.testing_utils import require_torch


if is_vision_available():
 from transformers import TvltImageProcessor

if is_speech_available():
 from transformers import TvltFeatureExtractor

from transformers import TvltProcessor






@require_torch
class  __magic_name__							(		unittest.TestCase    ):






       def       lowerCAmelCase		(      self)						->  str:




          '''simple docstring'''
          _UpperCAmelCase       :       Dict							   ='ZinengTang/tvlt-base'
          _UpperCAmelCase       :       Dict							   =tempfile.mkdtemp()






       def       lowerCAmelCase		(      self  ,							**snake_case)						->  Union[str, Any]:




          '''simple docstring'''
          return TvltImageProcessor.from_pretrained(self.checkpoint  ,							**snake_case)






       def       lowerCAmelCase		(      self  ,							**snake_case)						->  Dict:




          '''simple docstring'''
          return TvltFeatureExtractor.from_pretrained(self.checkpoint  ,							**snake_case)






       def       lowerCAmelCase		(      self)						->  Any:




          '''simple docstring'''
          shutil.rmtree(self.tmpdirname)






       def       lowerCAmelCase		(      self)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase       :       Any							   =self.get_image_processor()
          _UpperCAmelCase       :       Optional[Any]							   =self.get_feature_extractor()

          _UpperCAmelCase       :       str							   =TvltProcessor(image_processor=snake_case  ,							feature_extractor=snake_case)
          processor.save_pretrained(self.tmpdirname)
          _UpperCAmelCase       :       str							   =TvltProcessor.from_pretrained(self.tmpdirname)

          self.assertIsInstance(processor.feature_extractor  ,							snake_case)
          self.assertIsInstance(processor.image_processor  ,							snake_case)






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




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =self.get_image_processor()
          _UpperCAmelCase       :       List[Any]							   =self.get_feature_extractor()

          _UpperCAmelCase       :       str							   =TvltProcessor(image_processor=snake_case  ,							feature_extractor=snake_case)

          _UpperCAmelCase       :       Optional[int]							   =np.ones([1_2_0_0_0])

          _UpperCAmelCase       :       str							   =feature_extractor(snake_case  ,							return_tensors='np')
          _UpperCAmelCase       :       Dict							   =processor(audio=snake_case  ,							return_tensors='np')

          for key in audio_dict.keys():
             self.assertAlmostEqual(audio_dict[key].sum()  ,							input_processor[key].sum()  ,							delta=1E-2)






       def       lowerCAmelCase		(      self)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       Dict							   =self.get_image_processor()
          _UpperCAmelCase       :       int							   =self.get_feature_extractor()

          _UpperCAmelCase       :       int							   =TvltProcessor(image_processor=snake_case  ,							feature_extractor=snake_case)

          _UpperCAmelCase       :       Union[str, Any]							   =np.ones([3, 2_2_4, 2_2_4])

          _UpperCAmelCase       :       Optional[Any]							   =image_processor(snake_case  ,							return_tensors='np')
          _UpperCAmelCase       :       List[Any]							   =processor(images=snake_case  ,							return_tensors='np')

          for key in image_dict.keys():
             self.assertAlmostEqual(image_dict[key].sum()  ,							input_processor[key].sum()  ,							delta=1E-2)






       def       lowerCAmelCase		(      self)						->  List[str]:




          '''simple docstring'''
          _UpperCAmelCase       :       List[str]							   =self.get_image_processor()
          _UpperCAmelCase       :       Dict							   =self.get_feature_extractor()

          _UpperCAmelCase       :       Optional[int]							   =TvltProcessor(image_processor=snake_case  ,							feature_extractor=snake_case)

          _UpperCAmelCase       :       Optional[int]							   =np.ones([1_2_0_0_0])
          _UpperCAmelCase       :       str							   =np.ones([3, 2_2_4, 2_2_4])

          _UpperCAmelCase       :       Optional[int]							   =processor(audio=snake_case  ,							images=snake_case)

          self.assertListEqual(list(inputs.keys())  ,							['audio_values', 'audio_mask', 'pixel_values', 'pixel_mask'])

          # test if it raises when no input is passed
          with pytest.raises(snake_case):
             processor()






       def       lowerCAmelCase		(      self)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =self.get_image_processor()
          _UpperCAmelCase       :       Tuple							   =self.get_feature_extractor()

          _UpperCAmelCase       :       Dict							   =TvltProcessor(image_processor=snake_case  ,							feature_extractor=snake_case)

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

