

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


a		=logging.get_logger(__name__)






@add_end_docstrings(SCREAMING_SNAKE_CASE    )
class 	A_		(	SCREAMING_SNAKE_CASE    ):
							def __init__(		self		:      Dict       ,**SCREAMING_SNAKE_CASE__		:      Optional[Any]):
								super().__init__(**SCREAMING_SNAKE_CASE__)

								if self.framework != "pt":
									raise ValueError(F"The {self.__class__} is only available in PyTorch.")
								# No specific FOR_XXX available yet
							def __call__(		self		:      str       ,SCREAMING_SNAKE_CASE__		:      Union[np.ndarray, bytes, str]       ,**SCREAMING_SNAKE_CASE__		:      str):
								return super().__call__(SCREAMING_SNAKE_CASE__       ,**SCREAMING_SNAKE_CASE__)
							def    lowerCAmelCase					(		self		:      int       ,**SCREAMING_SNAKE_CASE__		:      List[str]):
								__lowerCamelCase    :    Dict 	=			{}
								if "candidate_labels" in kwargs:
									__lowerCamelCase    :    str 	=			kwargs['candidate_labels']
								if "hypothesis_template" in kwargs:
									__lowerCamelCase    :    Union[str, Any] 	=			kwargs['hypothesis_template']

								return preprocess_params, {}, {}
							def    lowerCAmelCase					(		self		:      Any       ,SCREAMING_SNAKE_CASE__		:      List[str]       ,SCREAMING_SNAKE_CASE__		:      List[Any]=None       ,SCREAMING_SNAKE_CASE__		:      List[str]="This is a sound of {}."):
								if isinstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__):
									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
										__lowerCamelCase    :    Tuple 	=			requests.get(SCREAMING_SNAKE_CASE__).content
									else:
										with open(SCREAMING_SNAKE_CASE__       ,'rb') as f:
											__lowerCamelCase    :    Optional[Any] 	=			f.read()

								if isinstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__):
									__lowerCamelCase    :    Any 	=			ffmpeg_read(SCREAMING_SNAKE_CASE__       ,self.feature_extractor.sampling_rate)

								if not isinstance(SCREAMING_SNAKE_CASE__       ,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')

								__lowerCamelCase    :    Any 	=			self.feature_extractor(
								    [audio]       ,sampling_rate=self.feature_extractor.sampling_rate       ,return_tensors='pt')
								__lowerCamelCase    :    List[Any] 	=			candidate_labels
								__lowerCamelCase    :    Tuple 	=			[hypothesis_template.format(SCREAMING_SNAKE_CASE__) for x in candidate_labels]
								__lowerCamelCase    :    Any 	=			self.tokenizer(SCREAMING_SNAKE_CASE__       ,return_tensors=self.framework       ,padding=SCREAMING_SNAKE_CASE__)
								__lowerCamelCase    :    List[str] 	=			[text_inputs]
								return inputs
							def    lowerCAmelCase					(		self		:      Dict       ,SCREAMING_SNAKE_CASE__		:      Tuple):
								__lowerCamelCase    :    List[Any] 	=			model_inputs.pop('candidate_labels')
								__lowerCamelCase    :    Any 	=			model_inputs.pop('text_inputs')
								if isinstance(text_inputs[0]       ,SCREAMING_SNAKE_CASE__):
									__lowerCamelCase    :    List[str] 	=			text_inputs[0]
								else:
									# Batching case.
									__lowerCamelCase    :    str 	=			text_inputs[0][0]

								__lowerCamelCase    :    Union[str, Any] 	=			self.model(**SCREAMING_SNAKE_CASE__       ,**SCREAMING_SNAKE_CASE__)

								__lowerCamelCase    :    Optional[Any] 	=			{
								    'candidate_labels': candidate_labels,
								    'logits': outputs.logits_per_audio,
								}
								return model_outputs


							def    lowerCAmelCase					(		self		:      List[Any]       ,SCREAMING_SNAKE_CASE__		:      Any):
								__lowerCamelCase    :    int 	=			model_outputs.pop('candidate_labels')
								__lowerCamelCase    :    Union[str, Any] 	=			model_outputs['logits'][0]

								if self.framework == "pt":
									__lowerCamelCase    :    Dict 	=			logits.softmax(dim=0)
									__lowerCamelCase    :    str 	=			probs.tolist()
								else:
									raise ValueError('`tf` framework not supported.')

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







from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
					from transformers import (
					    AutoConfig,
					    BertConfig,
					    GPTaConfig,
					    TaConfig,
					    TFAutoModel,
					    TFAutoModelForCausalLM,
					    TFAutoModelForMaskedLM,
					    TFAutoModelForPreTraining,
					    TFAutoModelForQuestionAnswering,
					    TFAutoModelForSeqaSeqLM,
					    TFAutoModelForSequenceClassification,
					    TFAutoModelWithLMHead,
					    TFBertForMaskedLM,
					    TFBertForPreTraining,
					    TFBertForQuestionAnswering,
					    TFBertForSequenceClassification,
					    TFBertModel,
					    TFGPTaLMHeadModel,
					    TFRobertaForMaskedLM,
					    TFTaForConditionalGeneration,
					)
					from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
					from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
					from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST

if is_torch_available():
					from transformers import (
					    AutoModel,
					    AutoModelForCausalLM,
					    AutoModelForMaskedLM,
					    AutoModelForPreTraining,
					    AutoModelForQuestionAnswering,
					    AutoModelForSeqaSeqLM,
					    AutoModelForSequenceClassification,
					    AutoModelWithLMHead,
					    BertForMaskedLM,
					    BertForPreTraining,
					    BertForQuestionAnswering,
					    BertForSequenceClassification,
					    BertModel,
					    GPTaLMHeadModel,
					    RobertaForMaskedLM,
					    TaForConditionalGeneration,
					)






@is_pt_tf_cross_test
class 	A_		(	unittest.TestCase    ):
							@slow
							def    lowerCAmelCase					(		self		:      List[str]):
								# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["bert-base-uncased"]:
									__lowerCamelCase    :    Optional[int] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Tuple 	=			TFAutoModel.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    str 	=			AutoModel.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      Optional[int]):
								# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["bert-base-uncased"]:
									__lowerCamelCase    :    str 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Tuple 	=			TFAutoModelForPreTraining.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    str 	=			AutoModelForPreTraining.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      Optional[int]):
								for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase    :    Union[str, Any] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Union[str, Any] 	=			TFAutoModelForCausalLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    Union[str, Any] 	=			TFAutoModelForCausalLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    List[Any] 	=			AutoModelForCausalLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    Any 	=			AutoModelForCausalLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      List[Any]):
								for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase    :    List[str] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    List[str] 	=			TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[Any] 	=			AutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      Tuple):
								for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase    :    Optional[Any] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[int] 	=			TFAutoModelForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    Dict 	=			TFAutoModelForMaskedLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    List[Any] 	=			AutoModelForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    Optional[Any] 	=			AutoModelForMaskedLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      str):
								for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase    :    Dict 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[Any] 	=			TFAutoModelForSeqaSeqLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    List[str] 	=			TFAutoModelForSeqaSeqLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Any 	=			AutoModelForSeqaSeqLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    List[str] 	=			AutoModelForSeqaSeqLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      Optional[Any]):
								# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["bert-base-uncased"]:
									__lowerCamelCase    :    List[Any] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[int] 	=			TFAutoModelForSequenceClassification.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    int 	=			AutoModelForSequenceClassification.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      Any):
								# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["bert-base-uncased"]:
									__lowerCamelCase    :    List[Any] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    str 	=			TFAutoModelForQuestionAnswering.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[int] 	=			AutoModelForQuestionAnswering.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							def    lowerCAmelCase					(		self		:      int):
								__lowerCamelCase    :    List[Any] 	=			TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
								self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								self.assertEqual(model.num_parameters()       ,1_4_4_1_0)
								self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE__)       ,1_4_4_1_0)

								__lowerCamelCase    :    Union[str, Any] 	=			AutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
								self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								self.assertEqual(model.num_parameters()       ,1_4_4_1_0)
								self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE__)       ,1_4_4_1_0)


							def    lowerCAmelCase					(		self		:      Tuple):
								__lowerCamelCase    :    str 	=			TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
								self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								self.assertEqual(model.num_parameters()       ,1_4_4_1_0)
								self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE__)       ,1_4_4_1_0)

								__lowerCamelCase    :    Optional[int] 	=			AutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
								self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								self.assertEqual(model.num_parameters()       ,1_4_4_1_0)
								self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE__)       ,1_4_4_1_0)




