




'''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  :				Union[str, Any]									=  logging.get_logger(__name__)






@add_end_docstrings(_lowerCamelCase     )
class 						a				(   _lowerCamelCase     ):


				def __init__(		self    :					Any       ,				**lowercase_    :					Any					):
									super().__init__(**lowercase_					)

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


				def __call__(		self    :					Dict       ,				lowercase_    :					Union[np.ndarray, bytes, str]       ,				**lowercase_    :					Dict					):
									return super().__call__(lowercase_       ,				**lowercase_					)


				def   A_ (		self    :					Union[str, Any]       ,				**lowercase_    :					List[str]					):
									snake_case_									=				{}
									if "candidate_labels" in kwargs:
														snake_case_									=				kwargs['''candidate_labels''']
									if "hypothesis_template" in kwargs:
														snake_case_									=				kwargs['''hypothesis_template''']

									return preprocess_params, {}, {}


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

									if isinstance(lowercase_       ,				lowercase_					):
														snake_case_									=				ffmpeg_read(lowercase_       ,				self.feature_extractor.sampling_rate					)

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

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


				def   A_ (		self    :					int       ,				lowercase_    :					str					):
									snake_case_									=				model_inputs.pop('''candidate_labels'''					)
									snake_case_									=				model_inputs.pop('''text_inputs'''					)
									if isinstance(text_inputs[0]       ,				lowercase_					):
														snake_case_									=				text_inputs[0]
									else:
														# Batching case.
														snake_case_									=				text_inputs[0][0]

									snake_case_									=				self.model(**lowercase_       ,				**lowercase_					)

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


				def   A_ (		self    :					Any       ,				lowercase_    :					int					):
									snake_case_									=				model_outputs.pop('''candidate_labels'''					)
									snake_case_									=				model_outputs['''logits'''][0]

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

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







"""simple docstring"""




from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, logging


if is_torch_available():
					import torch


lowerCAmelCase							:			int     							=							logging.get_logger(__name__)






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''
				__UpperCamelCase			  =						["pixel_values"]





				def __init__(       self		, _a = True		, _a = None		, _a = PILImageResampling.BILINEAR		, _a = True		, _a = None		, _a = True		, _a = 1 / 255		, _a = True		, _a = None		, _a = None		, **_a		, ):





							"""simple docstring"""
							super().__init__(**_a )
							lowerCamelCase			      =					size if size is not None else {"""shortest_edge""": 256}
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							lowerCamelCase			      =					crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
							lowerCamelCase			      =					get_size_dict(_a		, param_name="""crop_size""" )
							lowerCamelCase			      =					do_resize
							lowerCamelCase			      =					size
							lowerCamelCase			      =					resample
							lowerCamelCase			      =					do_center_crop
							lowerCamelCase			      =					crop_size
							lowerCamelCase			      =					do_rescale
							lowerCamelCase			      =					rescale_factor
							lowerCamelCase			      =					do_normalize
							lowerCamelCase			      =					image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
							lowerCamelCase			      =					image_std if image_std is not None else IMAGENET_STANDARD_STD





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = PILImageResampling.BICUBIC		, _a = None		, **_a		, ):





							"""simple docstring"""
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							if "shortest_edge" not in size:
										raise ValueError(f'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}' )
							lowerCamelCase			      =					get_resize_output_image_size(_a		, size=size["""shortest_edge"""]		, default_to_square=_a )
							return resize(_a		, size=_a		, resample=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = None		, **_a		, ):





							"""simple docstring"""
							lowerCamelCase			      =					get_size_dict(_a )
							if "height" not in size or "width" not in size:
										raise ValueError(f'The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}' )
							return center_crop(_a		, size=(size["""height"""], size["""width"""])		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = None		, **_a ):





							"""simple docstring"""
							return rescale(_a		, scale=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a		, _a = None		, **_a		, ):





							"""simple docstring"""
							return normalize(_a		, mean=_a		, std=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = ChannelDimension.FIRST		, **_a		, ):





							"""simple docstring"""
							lowerCamelCase			      =					do_resize if do_resize is not None else self.do_resize
							lowerCamelCase			      =					size if size is not None else self.size
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							lowerCamelCase			      =					resample if resample is not None else self.resample
							lowerCamelCase			      =					do_center_crop if do_center_crop is not None else self.do_center_crop
							lowerCamelCase			      =					crop_size if crop_size is not None else self.crop_size
							lowerCamelCase			      =					get_size_dict(_a		, param_name="""crop_size""" )
							lowerCamelCase			      =					do_rescale if do_rescale is not None else self.do_rescale
							lowerCamelCase			      =					rescale_factor if rescale_factor is not None else self.rescale_factor
							lowerCamelCase			      =					do_normalize if do_normalize is not None else self.do_normalize
							lowerCamelCase			      =					image_mean if image_mean is not None else self.image_mean
							lowerCamelCase			      =					image_std if image_std is not None else self.image_std

							lowerCamelCase			      =					make_list_of_images(_a )

							if not valid_images(_a ):
										raise ValueError(
										    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
										    """torch.Tensor, tf.Tensor or jax.ndarray.""" )

							if do_resize and size is None:
										raise ValueError("""Size must be specified if do_resize is True.""" )

							if do_center_crop and crop_size is None:
										raise ValueError("""Crop size must be specified if do_center_crop is True.""" )

							if do_rescale and rescale_factor is None:
										raise ValueError("""Rescale factor must be specified if do_rescale is True.""" )

							if do_normalize and (image_mean is None or image_std is None):
										raise ValueError("""Image mean and std must be specified if do_normalize is True.""" )

							# All transformations expect numpy arrays.
							lowerCamelCase			      =					[to_numpy_array(_a ) for image in images]

							if do_resize:
										lowerCamelCase			      =					[self.resize(image=_a		, size=_a		, resample=_a ) for image in images]

							if do_center_crop:
										lowerCamelCase			      =					[self.center_crop(image=_a		, size=_a ) for image in images]

							if do_rescale:
										lowerCamelCase			      =					[self.rescale(image=_a		, scale=_a ) for image in images]

							if do_normalize:
										lowerCamelCase			      =					[self.normalize(image=_a		, mean=_a		, std=_a ) for image in images]

							lowerCamelCase			      =					[to_channel_dimension_format(_a		, _a ) for image in images]

							lowerCamelCase			      =					{"""pixel_values""": images}
							return BatchFeature(data=_a		, tensor_type=_a )





				def    _lowerCAmelCase				(       self		, _a		, _a = None ):





							"""simple docstring"""
							lowerCamelCase			      =					outputs.logits

							# Resize logits and compute semantic segmentation maps
							if target_sizes is not None:
										if len(_a ) != len(_a ):
													raise ValueError(
													    """Make sure that you pass in as many target sizes as the batch dimension of the logits""" )

										if is_torch_tensor(_a ):
													lowerCamelCase			      =					target_sizes.numpy()

										lowerCamelCase			      =					[]

										for idx in range(len(_a ) ):
													lowerCamelCase			      =					torch.nn.functional.interpolate(
													    logits[idx].unsqueeze(dim=0 )		, size=target_sizes[idx]		, mode="""bilinear"""		, align_corners=_a )
													lowerCamelCase			      =					resized_logits[0].argmax(dim=0 )
													semantic_segmentation.append(_a )
							else:
										lowerCamelCase			      =					logits.argmax(dim=1 )
										lowerCamelCase			      =					[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0] )]

							return semantic_segmentation



