





'''simple docstring'''





from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    TFRoFormerForCausalLM,
				    TFRoFormerForMaskedLM,
				    TFRoFormerForMultipleChoice,
				    TFRoFormerForQuestionAnswering,
				    TFRoFormerForSequenceClassification,
				    TFRoFormerForTokenClassification,
				    TFRoFormerModel,
				)
				from transformers.models.roformer.modeling_tf_roformer import (
				    TFRoFormerSelfAttention,
				    TFRoFormerSinusoidalPositionalEmbedding,
				)



class    _a     :






							"""simple docstring"""

							def __init__(      self				:     Dict							,	a				:     Optional[Any]							,	a				:     int=13							,	a				:     int=7							,	a				:     List[str]=True							,	a				:     Union[str, Any]=True							,	a				:     Any=True							,	a				:     str=True							,	a				:     List[str]=99							,	a				:     List[str]=32							,	a				:     int=2							,	a				:     Any=4							,	a				:     List[Any]=37							,	a				:     Any="gelu"							,	a				:     List[str]=0.1							,	a				:     Optional[int]=0.1							,	a				:     Tuple=5_12							,	a				:     List[Any]=16							,	a				:     Any=2							,	a				:     Optional[Any]=0.02							,	a				:     str=3							,	a				:     Optional[Any]=4							,	a				:     Optional[int]=None							,	)	->int:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					parent
													SCREAMING_SNAKE_CASE__     :				Dict   =					13
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					7
													SCREAMING_SNAKE_CASE__     :				Tuple   =					True
													SCREAMING_SNAKE_CASE__     :				str   =					True
													SCREAMING_SNAKE_CASE__     :				int   =					True
													SCREAMING_SNAKE_CASE__     :				List[str]   =					True
													SCREAMING_SNAKE_CASE__     :				Dict   =					99
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					32
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					2
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					4
													SCREAMING_SNAKE_CASE__     :				Dict   =					37
													SCREAMING_SNAKE_CASE__     :				int   =					"gelu"
													SCREAMING_SNAKE_CASE__     :				str   =					0.1
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					0.1
													SCREAMING_SNAKE_CASE__     :				Dict   =					5_12
													SCREAMING_SNAKE_CASE__     :				str   =					16
													SCREAMING_SNAKE_CASE__     :				Dict   =					2
													SCREAMING_SNAKE_CASE__     :				str   =					0.02
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					3
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					4
													SCREAMING_SNAKE_CASE__     :				str   =					None

							def      A_  (      self				:     Dict    )	->Dict:
													SCREAMING_SNAKE_CASE__     :				Dict   =					ids_tensor([self.batch_size, self.seq_length]							,	self.vocab_size    )

													SCREAMING_SNAKE_CASE__     :				List[Any]   =					None
													if self.use_input_mask:
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					random_attention_mask([self.batch_size, self.seq_length]    )

													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					None
													if self.use_token_type_ids:
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					ids_tensor([self.batch_size, self.seq_length]							,	self.type_vocab_size    )

													SCREAMING_SNAKE_CASE__     :				int   =					None
													SCREAMING_SNAKE_CASE__     :				Dict   =					None
													SCREAMING_SNAKE_CASE__     :				int   =					None
													if self.use_labels:
																			SCREAMING_SNAKE_CASE__     :				Any   =					ids_tensor([self.batch_size]							,	self.type_sequence_label_size    )
																			SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					ids_tensor([self.batch_size, self.seq_length]							,	self.num_labels    )
																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					ids_tensor([self.batch_size]							,	self.num_choices    )

													SCREAMING_SNAKE_CASE__     :				str   =					RoFormerConfig(
													    vocab_size=self.vocab_size							,	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							,	max_position_embeddings=self.max_position_embeddings							,	type_vocab_size=self.type_vocab_size							,	initializer_range=self.initializer_range							,	return_dict=A__							,	)

													return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

							def      A_  (      self				:     Union[str, Any]							,	a				:     Optional[Any]							,	a				:     str							,	a				:     Optional[int]							,	a				:     Tuple							,	a				:     Union[str, Any]							,	a				:     Optional[int]							,	a				:     Optional[Any]    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					TFRoFormerModel(config=A__    )
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}

													SCREAMING_SNAKE_CASE__     :				List[str]   =					[input_ids, input_mask]
													SCREAMING_SNAKE_CASE__     :				str   =					model(A__    )

													SCREAMING_SNAKE_CASE__     :				str   =					model(A__    )

													self.parent.assertEqual(result.last_hidden_state.shape							,	(self.batch_size, self.seq_length, self.hidden_size)    )

							def      A_  (      self				:     List[Any]							,	a				:     Dict							,	a				:     Optional[int]							,	a				:     Optional[Any]							,	a				:     Optional[Any]							,	a				:     List[str]							,	a				:     Dict							,	a				:     Dict    )	->Optional[int]:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					True
													SCREAMING_SNAKE_CASE__     :				int   =					TFRoFormerForCausalLM(config=A__    )
													SCREAMING_SNAKE_CASE__     :				Any   =					{
													    "input_ids": input_ids,
													    "attention_mask": input_mask,
													    "token_type_ids": token_type_ids,
													}
													SCREAMING_SNAKE_CASE__     :				str   =					model(A__    )["logits"]
													self.parent.assertListEqual(
													    list(prediction_scores.numpy().shape    )							,	[self.batch_size, self.seq_length, self.vocab_size]    )

							def      A_  (      self				:     Dict							,	a				:     Tuple							,	a				:     str							,	a				:     Optional[Any]							,	a				:     Union[str, Any]							,	a				:     Union[str, Any]							,	a				:     Dict							,	a				:     int    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				Any   =					TFRoFormerForMaskedLM(config=A__    )
													SCREAMING_SNAKE_CASE__     :				Tuple   =					{
													    "input_ids": input_ids,
													    "attention_mask": input_mask,
													    "token_type_ids": token_type_ids,
													}
													SCREAMING_SNAKE_CASE__     :				Tuple   =					model(A__    )
													self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.seq_length, self.vocab_size)    )

							def      A_  (      self				:     int							,	a				:     Optional[int]							,	a				:     Optional[Any]							,	a				:     List[str]							,	a				:     List[Any]							,	a				:     Optional[Any]							,	a				:     Union[str, Any]							,	a				:     int    )	->Dict:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					self.num_labels
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					TFRoFormerForSequenceClassification(config=A__    )
													SCREAMING_SNAKE_CASE__     :				str   =					{
													    "input_ids": input_ids,
													    "attention_mask": input_mask,
													    "token_type_ids": token_type_ids,
													}

													SCREAMING_SNAKE_CASE__     :				str   =					model(A__    )
													self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.num_labels)    )

							def      A_  (      self				:     Any							,	a				:     int							,	a				:     Optional[Any]							,	a				:     Tuple							,	a				:     List[Any]							,	a				:     Tuple							,	a				:     List[str]							,	a				:     Optional[Any]    )	->List[str]:
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					self.num_choices
													SCREAMING_SNAKE_CASE__     :				Dict   =					TFRoFormerForMultipleChoice(config=A__    )
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					tf.tile(tf.expand_dims(A__							,	1    )							,	(1, self.num_choices, 1)    )
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					tf.tile(tf.expand_dims(A__							,	1    )							,	(1, self.num_choices, 1)    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					tf.tile(tf.expand_dims(A__							,	1    )							,	(1, self.num_choices, 1)    )
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					{
													    "input_ids": multiple_choice_inputs_ids,
													    "attention_mask": multiple_choice_input_mask,
													    "token_type_ids": multiple_choice_token_type_ids,
													}
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					model(A__    )
													self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.num_choices)    )

							def      A_  (      self				:     Optional[Any]							,	a				:     Dict							,	a				:     Optional[Any]							,	a				:     Any							,	a				:     Dict							,	a				:     str							,	a				:     int							,	a				:     Optional[Any]    )	->Dict:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.num_labels
													SCREAMING_SNAKE_CASE__     :				Any   =					TFRoFormerForTokenClassification(config=A__    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					{
													    "input_ids": input_ids,
													    "attention_mask": input_mask,
													    "token_type_ids": token_type_ids,
													}
													SCREAMING_SNAKE_CASE__     :				Tuple   =					model(A__    )
													self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.seq_length, self.num_labels)    )

							def      A_  (      self				:     Optional[int]							,	a				:     Optional[Any]							,	a				:     Dict							,	a				:     Tuple							,	a				:     List[str]							,	a				:     str							,	a				:     Optional[int]							,	a				:     str    )	->Dict:
													SCREAMING_SNAKE_CASE__     :				Any   =					TFRoFormerForQuestionAnswering(config=A__    )
													SCREAMING_SNAKE_CASE__     :				List[str]   =					{
													    "input_ids": input_ids,
													    "attention_mask": input_mask,
													    "token_type_ids": token_type_ids,
													}

													SCREAMING_SNAKE_CASE__     :				Any   =					model(A__    )
													self.parent.assertEqual(result.start_logits.shape							,	(self.batch_size, self.seq_length)    )
													self.parent.assertEqual(result.end_logits.shape							,	(self.batch_size, self.seq_length)    )






							def      A_  (      self				:     int    )	->str:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.prepare_config_and_inputs()
													(
													    (
													    SCREAMING_SNAKE_CASE__		
													),							(
													    SCREAMING_SNAKE_CASE__		
													),							(
													    SCREAMING_SNAKE_CASE__		
													),							(
													    SCREAMING_SNAKE_CASE__		
													),							(
													    SCREAMING_SNAKE_CASE__		
													),							(
													    SCREAMING_SNAKE_CASE__		
													),							(
													    SCREAMING_SNAKE_CASE__		
													),									
													)     :				Union[str, Any]   =					config_and_inputs
													SCREAMING_SNAKE_CASE__     :				Tuple   =					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
													return config, inputs_dict







@require_tf
class    _a     (				__a					,							__a					,							unittest.TestCase							):






							"""simple docstring"""

							snake_case_							 =						(
							    (
							        TFRoFormerModel,
							        TFRoFormerForCausalLM,
							        TFRoFormerForMaskedLM,
							        TFRoFormerForQuestionAnswering,
							        TFRoFormerForSequenceClassification,
							        TFRoFormerForTokenClassification,
							        TFRoFormerForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							snake_case_							 =						(
							    {
							        "feature-extraction": TFRoFormerModel,
							        "fill-mask": TFRoFormerForMaskedLM,
							        "question-answering": TFRoFormerForQuestionAnswering,
							        "text-classification": TFRoFormerForSequenceClassification,
							        "text-generation": TFRoFormerForCausalLM,
							        "token-classification": TFRoFormerForTokenClassification,
							        "zero-shot": TFRoFormerForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)

							snake_case_							 =						False
							snake_case_							 =						False

							def      A_  (      self				:     List[str]							,	a				:     str							,	a				:     int							,	a				:     Union[str, Any]							,	a				:     List[str]							,	a				:     List[Any]    )	->Union[str, Any]:
													if pipeline_test_casse_name == "TextGenerationPipelineTests":
																			return True

													return False

							def      A_  (      self				:     Tuple    )	->Any:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					TFRoFormerModelTester(self    )
													SCREAMING_SNAKE_CASE__     :				int   =					ConfigTester(self							,	config_class=A__							,	hidden_size=37    )

							def      A_  (      self				:     str    )	->str:
													self.config_tester.run_common_tests()

							def      A_  (      self				:     List[str]    )	->Any:
													SCREAMING_SNAKE_CASE__     :				str   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*A__    )

							def      A_  (      self				:     Dict    )	->List[str]:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_lm(*A__    )

							def      A_  (      self				:     Tuple    )	->int:
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_lm_head(*A__    )

							def      A_  (      self				:     Tuple    )	->Tuple:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_multiple_choice(*A__    )

							def      A_  (      self				:     str    )	->Tuple:
													SCREAMING_SNAKE_CASE__     :				str   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_question_answering(*A__    )

							def      A_  (      self				:     Tuple    )	->Dict:
													SCREAMING_SNAKE_CASE__     :				Any   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_sequence_classification(*A__    )

							def      A_  (      self				:     Any    )	->List[Any]:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_token_classification(*A__    )






							@slow
							def      A_  (      self				:     Tuple    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				int   =					TFRoFormerModel.from_pretrained("junnyu/roformer_chinese_base"    )
													self.assertIsNotNone(A__    )







@require_tf
class    _a     (				unittest.TestCase							):






							"""simple docstring"""

							@slow
							def      A_  (      self				:     Union[str, Any]    )	->int:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					TFRoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base"    )
													SCREAMING_SNAKE_CASE__     :				str   =					tf.constant([[0, 1, 2, 3, 4, 5]]    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					model(A__    )[0]

													# TODO Replace vocab size
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					5_00_00

													SCREAMING_SNAKE_CASE__     :				List[str]   =					[1, 6, vocab_size]
													self.assertEqual(output.shape							,	A__    )

													print(output[:, :3, :3]    )

													# TODO Replace values below with what was printed above.
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					tf.constant(
													    [
													        [
													            [-0.1205_3341, -1.026_4901, 0.2922_1946],
													            [-1.513_3783, 0.19_7433, 0.1519_0607],
													            [-5.013_5403, -3.90_0256, -0.8403_8764],
													        ]
													    ]    )
													tf.debugging.assert_near(output[:, :3, :3]							,	A__							,	atol=1E-4    )







@require_tf
class    _a     (				unittest.TestCase							):






							"""simple docstring"""

							snake_case_							 =						1e-4

							def      A_  (      self				:     Any    )	->List[str]:
													SCREAMING_SNAKE_CASE__     :				str   =					tf.constant([[4, 10]]    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					TFRoFormerSinusoidalPositionalEmbedding(num_positions=6							,	embedding_dim=6    )

													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					emba(input_ids.shape    )
													SCREAMING_SNAKE_CASE__     :				Dict   =					tf.constant(
													    [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]]    )

													tf.debugging.assert_near(A__							,	A__							,	atol=self.tolerance    )






							def      A_  (      self				:     Optional[int]    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				Tuple   =					tf.constant(
													    [
													        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
													        [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
													        [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
													    ]    )
													SCREAMING_SNAKE_CASE__     :				str   =					TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_12							,	embedding_dim=5_12    )
													emba([2, 16, 5_12]    )
													SCREAMING_SNAKE_CASE__     :				int   =					emba.weight[:3, :5]

													tf.debugging.assert_near(A__							,	A__							,	atol=self.tolerance    )







@require_tf
class    _a     (				unittest.TestCase							):






							"""simple docstring"""

							snake_case_							 =						1e-4

							def      A_  (      self				:     str    )	->List[Any]:
													# 2,12,16,64
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					tf.reshape(tf.range(2 * 12 * 16 * 64							,	dtype=tf.floataa    )							,	shape=(2, 12, 16, 64)    ) / 1_00

													SCREAMING_SNAKE_CASE__     :				Dict   =					-tf.reshape(tf.range(2 * 12 * 16 * 64							,	dtype=tf.floataa    )							,	shape=(2, 12, 16, 64)    ) / 1_00

													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					TFRoFormerSinusoidalPositionalEmbedding(num_positions=32							,	embedding_dim=64    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					embed_positions([2, 16, 7_68]    )[None, None, :, :]

													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Dict   =					TFRoFormerSelfAttention.apply_rotary_position_embeddings(
													    A__							,	A__							,	A__    )

													SCREAMING_SNAKE_CASE__     :				Dict   =					tf.constant(
													    [
													        [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
													        [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
													        [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
													        [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
													        [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
													        [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
													    ]    )
													SCREAMING_SNAKE_CASE__     :				Tuple   =					tf.constant(
													    [
													        [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
													        [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
													        [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
													        [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
													        [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
													        [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
													    ]    )

													tf.debugging.assert_near(query_layer[0, 0, :6, :8]							,	A__							,	atol=self.tolerance    )
													tf.debugging.assert_near(key_layer[0, 0, :6, :8]							,	A__							,	atol=self.tolerance    )






import unittest

from datasets import load_dataset

from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow



@is_pipeline_test
@require_torch
class    _a     (				unittest.TestCase							):






							"""simple docstring"""

							@require_torch
							def      A_  (      self				:     Dict    )	->str:
													SCREAMING_SNAKE_CASE__     :				Any   =					pipeline(
													    task="zero-shot-audio-classification"							,	model="hf-internal-testing/tiny-clap-htsat-unfused"    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					load_dataset("ashraq/esc50"    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					dataset["train"]["audio"][-1]["array"]
													SCREAMING_SNAKE_CASE__     :				int   =					audio_classifier(a							,	candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"]    )
													self.assertEqual(
													    nested_simplify(a    )							,	[{"score": 0.501, "label": "Sound of a dog"}, {"score": 0.499, "label": "Sound of vaccum cleaner"}]							,	)

							@unittest.skip("No models are available in TF"    )
							def      A_  (      self				:     int    )	->Union[str, Any]:
													pass

							@slow
							@require_torch
							def      A_  (      self				:     int    )	->str:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					pipeline(
													    task="zero-shot-audio-classification"							,	model="laion/clap-htsat-unfused"							,	)
													# This is an audio of a dog
													SCREAMING_SNAKE_CASE__     :				int   =					load_dataset("ashraq/esc50"    )
													SCREAMING_SNAKE_CASE__     :				str   =					dataset["train"]["audio"][-1]["array"]
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					audio_classifier(a							,	candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"]    )

													self.assertEqual(
													    nested_simplify(a    )							,	[
													        {"score": 0.999, "label": "Sound of a dog"},
													        {"score": 0.001, "label": "Sound of vaccum cleaner"},
													    ]							,	)

													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					audio_classifier([audio] * 5							,	candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"]    )
													self.assertEqual(
													    nested_simplify(a    )							,	[
													        [
													            {"score": 0.999, "label": "Sound of a dog"},
													            {"score": 0.001, "label": "Sound of vaccum cleaner"},
													        ],
													    ]
													    * 5							,	)
													SCREAMING_SNAKE_CASE__     :				int   =					audio_classifier(
													    [audio] * 5							,	candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"]							,	batch_size=5    )
													self.assertEqual(
													    nested_simplify(a    )							,	[
													        [
													            {"score": 0.999, "label": "Sound of a dog"},
													            {"score": 0.001, "label": "Sound of vaccum cleaner"},
													        ],
													    ]
													    * 5							,	)






							@unittest.skip("No models are available in TF"    )
							def      A_  (      self				:     Optional[int]    )	->Union[str, Any]:
													pass