



"""simple docstring"""







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(UpperCamelCase     )
class      UpperCAmelCase__		(      UpperCamelCase     ):



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






									'''simple docstring'''

									super().__init__(**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  :    int      ,							snake_case  :    Union[np.ndarray, bytes, str]      ,							**snake_case  :    Dict				)			->						Union[str, Any]:






									'''simple docstring'''

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



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






									'''simple docstring'''

									A         =					{}
									if "candidate_labels" in kwargs:
																A         =					kwargs['candidate_labels']
									if "hypothesis_template" in kwargs:
																A         =					kwargs['hypothesis_template']

									return preprocess_params, {}, {}



		def 					A_		( self  :    List[Any]      ,							snake_case  :    Optional[int]      ,							snake_case  :    str=None      ,							snake_case  :    List[str]="This is a sound of {}."				)			->						Any:






									'''simple docstring'''

									if isinstance(snake_case      ,							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
																							A         =					requests.get(snake_case				).content
																else:
																							with open(snake_case      ,							'rb'				) as f:
																														A         =					f.read()

									if isinstance(snake_case      ,							snake_case				):
																A         =					ffmpeg_read(snake_case      ,							self.feature_extractor.sampling_rate				)

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

									A         =					self.feature_extractor(
									    [audio]      ,							sampling_rate=self.feature_extractor.sampling_rate      ,							return_tensors='pt'				)
									A         =					candidate_labels
									A         =					[hypothesis_template.format(snake_case				) for x in candidate_labels]
									A         =					self.tokenizer(snake_case      ,							return_tensors=self.framework      ,							padding=snake_case				)
									A         =					[text_inputs]
									return inputs



		def 					A_		( self  :    Optional[int]      ,							snake_case  :    Dict				)			->						List[str]:






									'''simple docstring'''

									A         =					model_inputs.pop('candidate_labels'				)
									A         =					model_inputs.pop('text_inputs'				)
									if isinstance(text_inputs[0]      ,							snake_case				):
																A         =					text_inputs[0]
									else:
																# Batching case.
																A         =					text_inputs[0][0]

									A         =					self.model(**snake_case      ,							**snake_case				)

									A         =					{
									    'candidate_labels': candidate_labels,
									    'logits': outputs.logits_per_audio,
									}
									return model_outputs



		def 					A_		( self  :    Dict      ,							snake_case  :    str				)			->						str:






									'''simple docstring'''

									A         =					model_outputs.pop('candidate_labels'				)
									A         =					model_outputs['logits'][0]

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

									A         =					[
									    {'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"""







from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching

def   lowerCAmelCase__			(     ) ->							Optional[Any]:
							import os as original_os
							from os import path as original_path
							from os import rename as original_rename
							from os.path import dirname as original_dirname
							from os.path import join as original_join

							assert _test_patching.os is original_os
							assert _test_patching.path is original_path
							assert _test_patching.join is original_join

							assert _test_patching.renamed_os is original_os
							assert _test_patching.renamed_path is original_path
							assert _test_patching.renamed_join is original_join

							A         =					'__test_patch_submodule_mock__'
							with patch_submodule(_test_patching				,      'os.path.join'				,      lowerCamelCase__			):
														# Every way to access os.path.join must be patched, and the rest must stay untouched

														# check os.path.join
														assert isinstance(_test_patching.os				,      _PatchedModuleObj			)
														assert isinstance(_test_patching.os.path				,      _PatchedModuleObj			)
														assert _test_patching.os.path.join is mock

														# check path.join
														assert isinstance(_test_patching.path				,      _PatchedModuleObj			)
														assert _test_patching.path.join is mock

														# check join
														assert _test_patching.join is mock

														# check that the other attributes are untouched
														assert _test_patching.os.rename is original_rename
														assert _test_patching.path.dirname is original_dirname
														assert _test_patching.os.path.dirname is original_dirname

														# Even renamed modules or objects must be patched

														# check renamed_os.path.join
														assert isinstance(_test_patching.renamed_os				,      _PatchedModuleObj			)
														assert isinstance(_test_patching.renamed_os.path				,      _PatchedModuleObj			)
														assert _test_patching.renamed_os.path.join is mock

														# check renamed_path.join
														assert isinstance(_test_patching.renamed_path				,      _PatchedModuleObj			)
														assert _test_patching.renamed_path.join is mock

														# check renamed_join
														assert _test_patching.renamed_join is mock

														# check that the other attributes are untouched
														assert _test_patching.renamed_os.rename is original_rename
														assert _test_patching.renamed_path.dirname is original_dirname
														assert _test_patching.renamed_os.path.dirname is original_dirname

							# check that everthing is back to normal when the patch is over

							assert _test_patching.os is original_os
							assert _test_patching.path is original_path
							assert _test_patching.join is original_join

							assert _test_patching.renamed_os is original_os
							assert _test_patching.renamed_path is original_path
							assert _test_patching.renamed_join is original_join

def   lowerCAmelCase__			(     ) ->							str:
							assert _test_patching.open is open

							A         =					'__test_patch_submodule_builtin_mock__'
							# _test_patching has "open" in its globals
							assert _test_patching.open is open
							with patch_submodule(_test_patching				,      'open'				,      lowerCamelCase__			):
														assert _test_patching.open is mock

							# check that everthing is back to normal when the patch is over

							assert _test_patching.open is open

def   lowerCAmelCase__			(     ) ->							List[Any]:
							# pandas.read_csv is not present in _test_patching
							A         =					'__test_patch_submodule_missing_mock__'
							with patch_submodule(_test_patching				,      'pandas.read_csv'				,      lowerCamelCase__			):
														pass

def   lowerCAmelCase__			(     ) ->							Union[str, Any]:
							# builtin should always be mocked even if they're not in the globals
							# in case they're loaded at one point
							A         =					'__test_patch_submodule_missing_builtin_mock__'
							# _test_patching doesn't have "len" in its globals
							assert getattr(_test_patching				,      'len'				,      lowerCamelCase__			) is None
							with patch_submodule(_test_patching				,      'len'				,      lowerCamelCase__			):
														assert _test_patching.len is mock
							assert _test_patching.len is len

def   lowerCAmelCase__			(     ) ->							Union[str, Any]:
							A         =					'__test_patch_submodule_start_and_stop_mock__'
							A         =					patch_submodule(_test_patching				,      'open'				,      lowerCamelCase__			)
							assert _test_patching.open is open
							patch.start()
							assert _test_patching.open is mock
							patch.stop()
							assert _test_patching.open is open

def   lowerCAmelCase__			(     ) ->							int:
							from os import rename as original_rename
							from os.path import dirname as original_dirname
							from os.path import join as original_join

							A         =					'__test_patch_submodule_successive_join__'
							A         =					'__test_patch_submodule_successive_dirname__'
							A         =					'__test_patch_submodule_successive_rename__'
							assert _test_patching.os.path.join is original_join
							assert _test_patching.os.path.dirname is original_dirname
							assert _test_patching.os.rename is original_rename

							with patch_submodule(_test_patching				,      'os.path.join'				,      lowerCamelCase__			):
														with patch_submodule(_test_patching				,      'os.rename'				,      lowerCamelCase__			):
																					with patch_submodule(_test_patching				,      'os.path.dirname'				,      lowerCamelCase__			):
																												assert _test_patching.os.path.join is mock_join
																												assert _test_patching.os.path.dirname is mock_dirname
																												assert _test_patching.os.rename is mock_rename

    # try another order
							with patch_submodule(_test_patching				,      'os.rename'				,      lowerCamelCase__			):
														with patch_submodule(_test_patching				,      'os.path.join'				,      lowerCamelCase__			):
																					with patch_submodule(_test_patching				,      'os.path.dirname'				,      lowerCamelCase__			):
																												assert _test_patching.os.path.join is mock_join
																												assert _test_patching.os.path.dirname is mock_dirname
																												assert _test_patching.os.rename is mock_rename

							assert _test_patching.os.path.join is original_join
							assert _test_patching.os.path.dirname is original_dirname
							assert _test_patching.os.rename is original_rename

def   lowerCAmelCase__			(     ) ->							Optional[Any]:
							A         =					'__test_patch_submodule_doesnt_exist_mock__'
							with patch_submodule(_test_patching				,      '__module_that_doesn_exist__.__attribute_that_doesn_exist__'				,      lowerCamelCase__			):
														pass
							with patch_submodule(_test_patching				,      'os.__attribute_that_doesn_exist__'				,      lowerCamelCase__			):
														pass



