
"""simple docstring"""


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import GLPNImageProcessor







class 					lowerCAmelCase_					(   unittest.TestCase     ):



						'''simple docstring'''


						def __init__(			self  :   Any	,A_  :   Optional[int]	,A_  :   str=7	,A_  :   Any=3	,A_  :   Any=18	,A_  :   Union[str, Any]=30	,A_  :   List[Any]=400	,A_  :   Union[str, Any]=True	,A_  :   Dict=32	,A_  :   int=True	,)  -> Union[str, Any]:
							A     = parent
							A     = batch_size
							A     = num_channels
							A     = image_size
							A     = min_resolution
							A     = max_resolution
							A     = do_resize
							A     = size_divisor
							A     = do_rescale




						def     _SCREAMING_SNAKE_CASE   (			self  :   Dict   )  -> List[Any]:
							return {
							    "do_resize": self.do_resize,
							    "size_divisor": self.size_divisor,
							    "do_rescale": self.do_rescale,
							}







@require_torch
@require_vision
class 					lowerCAmelCase_					(   _lowercase		,       unittest.TestCase     ):



						'''simple docstring'''


						_lowerCamelCase:     List[Any]   =     GLPNImageProcessor if is_vision_available() else None


						def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple   )  -> Optional[int]:
							A     = GLPNImageProcessingTester(self   )


						@property
						def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple   )  -> Optional[int]:
							return self.image_processor_tester.prepare_image_processor_dict()


						def     _SCREAMING_SNAKE_CASE   (			self  :   str   )  -> Dict:
							A     = self.image_processing_class(**self.image_processor_dict   )
							self.assertTrue(hasattr(A_	,'do_resize'   )   )
							self.assertTrue(hasattr(A_	,'size_divisor'   )   )
							self.assertTrue(hasattr(A_	,'resample'   )   )
							self.assertTrue(hasattr(A_	,'do_rescale'   )   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple   )  -> Union[str, Any]:
							pass


						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[int]   )  -> Optional[Any]:
							# Initialize image_processing
							A     = self.image_processing_class(**self.image_processor_dict   )
							# create random PIL images
							A     = prepare_image_inputs(self.image_processor_tester	,equal_resolution=A_   )
							for image in image_inputs:
								self.assertIsInstance(A_	,Image.Image   )

							# Test not batched input (GLPNImageProcessor doesn't support batching)
							A     = image_processing(image_inputs[0]	,return_tensors='pt'   ).pixel_values
							self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0   )
							self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Union[str, Any]   )  -> str:
							# Initialize image_processing
							A     = self.image_processing_class(**self.image_processor_dict   )
							# create random numpy tensors
							A     = prepare_image_inputs(self.image_processor_tester	,equal_resolution=A_	,numpify=A_   )
							for image in image_inputs:
								self.assertIsInstance(A_	,np.ndarray   )

							# Test not batched input (GLPNImageProcessor doesn't support batching)
							A     = image_processing(image_inputs[0]	,return_tensors='pt'   ).pixel_values
							self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0   )
							self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0   )




						def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple   )  -> Tuple:
							# Initialize image_processing
							A     = self.image_processing_class(**self.image_processor_dict   )
							# create random PyTorch tensors
							A     = prepare_image_inputs(self.image_processor_tester	,equal_resolution=A_	,torchify=A_   )
							for image in image_inputs:
								self.assertIsInstance(A_	,torch.Tensor   )

							# Test not batched input (GLPNImageProcessor doesn't support batching)
							A     = image_processing(image_inputs[0]	,return_tensors='pt'   ).pixel_values
							self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0   )
							self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0   )

'''simple docstring'''

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool




class    lowerCAmelCase       (     UpperCamelCase_  ):
 A_				:				int	=			"""openai/whisper-base"""
 A_				:				str	=			(
     """This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the """
     """transcribed text."""
 )
 A_				:				Union[str, Any]	=			"""transcriber"""
 A_				:				Tuple	=			WhisperProcessor
 A_				:				Dict	=			WhisperForConditionalGeneration

 A_				:				Tuple	=			["""audio"""]
 A_				:				Optional[int]	=			["""text"""]


 def    _A	(    self  : Optional[int]			,							a__  : Optional[int]    ):
  '''simple docstring'''

  return self.pre_processor(a__			,							return_tensors="pt"    ).input_features


 def    _A	(    self  : List[str]			,							a__  : Union[str, Any]    ):
  '''simple docstring'''

  return self.model.generate(inputs=a__    )


 def    _A	(    self  : Optional[Any]			,							a__  : Dict    ):
  '''simple docstring'''

  return self.pre_processor.batch_decode(a__			,							skip_special_tokens=a__    )[0]





