





from collections import UserDict
from typing import Union

import numpy as np
import requests

from ..utils import (
    add_end_docstrings,
    logging,
)
from .audio_classification import ffmpeg_read
from .base import PIPELINE_INIT_ARGS, Pipeline


_lowerCAmelCase							:					Union[str, Any]		    =		logging.get_logger(__name__)


@add_end_docstrings(a_							)
class     __magic_name__     (							a_							):





     """simple docstring"""



     def __init__(							self				:Dict	,					**snake_case				:Tuple     ):





        '''simple docstring'''




        super().__init__(**_A     )

        if self.framework != "pt":
           raise ValueError(f"The {self.__class__} is only available in PyTorch."     )
        # No specific FOR_XXX available yet



     def __call__(							self				:Optional[Any]	,					snake_case				:List[str]	,					**snake_case				:Optional[int]     ):





        '''simple docstring'''




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



     def   SCREAMING_SNAKE_CASE						(							self				:Tuple	,					**snake_case				:Any     ):





        '''simple docstring'''




        A_    : int								=	{}
        if "candidate_labels" in kwargs:
           A_    : Tuple								=	kwargs["candidate_labels"]
        if "hypothesis_template" in kwargs:
           A_    : Any								=	kwargs["hypothesis_template"]

        return preprocess_params, {}, {}



     def   SCREAMING_SNAKE_CASE						(							self				:Tuple	,					snake_case				:int	,					snake_case				:Any=None	,					snake_case				:Tuple="This is a sound of {}."     ):





        '''simple docstring'''




        if isinstance(_A	,					_A     ):
           if audio.startswith("http://"     ) or audio.startswith("https://"     ):
              # We need to actually check for a real protocol, otherwise it's impossible to use a local file
              # like http_huggingface_co.png
              A_    : Tuple								=	requests.get(_A     ).content
           else:
              with open(_A	,					"rb"     ) as f:
                 A_    : int								=	f.read()

        if isinstance(_A	,					_A     ):
           A_    : int								=	ffmpeg_read(_A	,					self.feature_extractor.sampling_rate     )

        if not isinstance(_A	,					np.ndarray     ):
           raise ValueError("We expect a numpy ndarray as input"     )
        if len(audio.shape     ) != 1:
           raise ValueError("We expect a single channel audio input for ZeroShotAudioClassificationPipeline"     )

        A_    : Optional[Any]								=	self.feature_extractor(
            [audio]	,					sampling_rate=self.feature_extractor.sampling_rate	,					return_tensors="pt"     )
        A_    : Optional[int]								=	candidate_labels
        A_    : Tuple								=	[hypothesis_template.format(_A     ) for x in candidate_labels]
        A_    : Optional[Any]								=	self.tokenizer(_A	,					return_tensors=self.framework	,					padding=_A     )
        A_    : Tuple								=	[text_inputs]
        return inputs



     def   SCREAMING_SNAKE_CASE						(							self				:str	,					snake_case				:str     ):





        '''simple docstring'''




        A_    : Optional[int]								=	model_inputs.pop("candidate_labels"     )
        A_    : List[Any]								=	model_inputs.pop("text_inputs"     )
        if isinstance(text_inputs[0]	,					_A     ):
           A_    : str								=	text_inputs[0]
        else:
           # Batching case.
           A_    : Dict								=	text_inputs[0][0]

        A_    : Dict								=	self.model(**_A	,					**_A     )

        A_    : Dict								=	{
            "candidate_labels": candidate_labels,
            "logits": outputs.logits_per_audio,
        }
        return model_outputs





     def   SCREAMING_SNAKE_CASE						(							self				:Union[str, Any]	,					snake_case				:Optional[int]     ):





        '''simple docstring'''




        A_    : Any								=	model_outputs.pop("candidate_labels"     )
        A_    : Dict								=	model_outputs["logits"][0]

        if self.framework == "pt":
           A_    : str								=	logits.softmax(dim=0     )
           A_    : List[str]								=	probs.tolist()
        else:
           raise ValueError("`tf` framework not supported."     )

        A_    : Optional[int]								=	[
            {"score": score, "label": candidate_label}
            for score, candidate_label in sorted(zip(_A	,					_A     )	,					key=lambda snake_case     : -x[0]     )
        ]
        return result







from __future__ import annotations

import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import TFViTForImageClassification, TFViTModel


if is_vision_available():
				from PIL import Image

				from transformers import ViTImageProcessor

class 	A_       :
	def __init__(    self							,					_A							,					_A=1_3							,					_A=3_0							,					_A=2							,					_A=3							,					_A=True							,					_A=True							,					_A=3_2							,					_A=2							,					_A=4							,					_A=3_7							,					_A="gelu"							,					_A=0.1							,					_A=0.1							,					_A=1_0							,					_A=0.02							,					_A=3							,					_A=None							,					):






				'''simple docstring'''







				UpperCAmelCase   		=				parent
				UpperCAmelCase   		=				batch_size
				UpperCAmelCase   		=				image_size
				UpperCAmelCase   		=				patch_size
				UpperCAmelCase   		=				num_channels
				UpperCAmelCase   		=				is_training
				UpperCAmelCase   		=				use_labels
				UpperCAmelCase   		=				hidden_size
				UpperCAmelCase   		=				num_hidden_layers
				UpperCAmelCase   		=				num_attention_heads
				UpperCAmelCase   		=				intermediate_size
				UpperCAmelCase   		=				hidden_act
				UpperCAmelCase   		=				hidden_dropout_prob
				UpperCAmelCase   		=				attention_probs_dropout_prob
				UpperCAmelCase   		=				type_sequence_label_size
				UpperCAmelCase   		=				initializer_range
				UpperCAmelCase   		=				scope

				# in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
				UpperCAmelCase   		=				(image_size // patch_size) ** 2
				UpperCAmelCase   		=				num_patches + 1
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

				UpperCAmelCase   		=				None
				if self.use_labels:
							UpperCAmelCase   		=				ids_tensor([self.batch_size]							,					self.type_sequence_label_size		)

				UpperCAmelCase   		=				self.get_config()

				return config, pixel_values, labels
	def      _lowercase				(    self		):






				'''simple docstring'''







				return ViTConfig(
				    image_size=self.image_size							,					patch_size=self.patch_size							,					num_channels=self.num_channels							,					hidden_size=self.hidden_size							,					num_hidden_layers=self.num_hidden_layers							,					num_attention_heads=self.num_attention_heads							,					intermediate_size=self.intermediate_size							,					hidden_act=self.hidden_act							,					hidden_dropout_prob=self.hidden_dropout_prob							,					attention_probs_dropout_prob=self.attention_probs_dropout_prob							,					is_decoder=_A							,					initializer_range=self.initializer_range							,					)
	def      _lowercase				(    self							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				TFViTModel(config=_A		)
				UpperCAmelCase   		=				model(_A							,					training=_A		)
				self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size)		)

				# Test with an image with different size than the one specified in config.
				UpperCAmelCase   		=				self.image_size // 2
				UpperCAmelCase   		=				pixel_values[:, :, :image_size, :image_size]
				UpperCAmelCase   		=				model(_A							,					interpolate_pos_encoding=_A							,					training=_A		)
				UpperCAmelCase   		=				(image_size // self.patch_size) ** 2 + 1
				self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, seq_length, self.hidden_size)		)
	def      _lowercase				(    self							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.type_sequence_label_size
				UpperCAmelCase   		=				TFViTForImageClassification(_A		)
				UpperCAmelCase   		=				model(_A							,					labels=_A							,					training=_A		)
				self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.type_sequence_label_size)		)

				# Test with an image with different size than the one specified in config.
				UpperCAmelCase   		=				self.image_size // 2
				UpperCAmelCase   		=				pixel_values[:, :, :image_size, :image_size]
				UpperCAmelCase   		=				model(_A							,					interpolate_pos_encoding=_A							,					training=_A		)
				self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.type_sequence_label_size)		)

				# test greyscale images
				UpperCAmelCase   		=				1
				UpperCAmelCase   		=				TFViTForImageClassification(_A		)
				UpperCAmelCase   		=				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
				UpperCAmelCase   		=				model(_A		)
				self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.type_sequence_label_size)		)







	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.prepare_config_and_inputs()
				UpperCAmelCase		,			UpperCAmelCase		,			UpperCAmelCase   		=				config_and_inputs
				UpperCAmelCase   		=				{'''pixel_values''': pixel_values}
				return config, inputs_dict

@require_tf
class 	A_       (a_     ,							a_     ,							unittest.TestCase			):
	UpperCAmelCase__					=			(TFViTModel, TFViTForImageClassification) if is_tf_available() else ()
	UpperCAmelCase__					=			(
	    {'''feature-extraction''': TFViTModel, '''image-classification''': TFViTForImageClassification}
	    if is_tf_available()
	    else {}
	)

	UpperCAmelCase__					=			False
	UpperCAmelCase__					=			False
	UpperCAmelCase__					=			False
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				TFViTModelTester(self		)
				UpperCAmelCase   		=				ConfigTester(self							,					config_class=_A							,					has_text_modality=_A							,					hidden_size=3_7		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				self.config_tester.run_common_tests()
	@unittest.skip(reason='''ViT does not use inputs_embeds'''		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				pass
	@unittest.skip(reason='''ViT does not use inputs_embeds'''		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				pass
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase		,			UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							UpperCAmelCase   		=				model_class(_A		)
							self.assertIsInstance(model.get_input_embeddings()							,					(tf.keras.layers.Layer)		)
							UpperCAmelCase   		=				model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(_A							,					tf.keras.layers.Layer		)		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase		,			UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							UpperCAmelCase   		=				model_class(_A		)
							UpperCAmelCase   		=				inspect.signature(model.call		)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							UpperCAmelCase   		=				[*signature.parameters.keys()]

							UpperCAmelCase   		=				['''pixel_values''']
							self.assertListEqual(arg_names[:1]							,					_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*_A		)







	@slow
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				TFViTModel.from_pretrained('''google/vit-base-patch16-224'''		)
				self.assertIsNotNone(_A		)





def 						__SCREAMING_SNAKE_CASE  (				)  ->				Optional[Any]:







			'''simple docstring'''

			UpperCAmelCase   		=				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
			return image






@require_tf
@require_vision
class 	A_       (unittest.TestCase			):
	@cached_property
	def      _lowercase				(    self		):






				'''simple docstring'''







				return ViTImageProcessor.from_pretrained('''google/vit-base-patch16-224'''		) if is_vision_available() else None







	@slow
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				TFViTForImageClassification.from_pretrained('''google/vit-base-patch16-224'''		)

				UpperCAmelCase   		=				self.default_image_processor
				UpperCAmelCase   		=				prepare_img()
				UpperCAmelCase   		=				image_processor(images=_A							,					return_tensors='''tf'''		)

				# forward pass
				UpperCAmelCase   		=				model(**_A		)

				# verify the logits
				UpperCAmelCase   		=				tf.TensorShape((1, 1_0_0_0)		)
				self.assertEqual(outputs.logits.shape							,					_A		)

				UpperCAmelCase   		=				tf.constant([-0.27_44, 0.82_15, -0.08_36]		)

				tf.debugging.assert_near(outputs.logits[0, :3]							,					_A							,					atol=1E-4		)



