

'''simple docstring'''


import random
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():
						import PIL

						from transformers import FlavaImageProcessor
						from transformers.image_utils import PILImageResampling
						from transformers.models.flava.image_processing_flava import (
						    FLAVA_CODEBOOK_MEAN,
						    FLAVA_CODEBOOK_STD,
						    FLAVA_IMAGE_MEAN,
						    FLAVA_IMAGE_STD,
						)
else:
						lowerCAmelCase__      				=			lowerCAmelCase__      				=			lowerCAmelCase__      				=			lowerCAmelCase__      				=			None



class        lowercase    (	unittest.TestCase			):


							def __init__(      self     ,      _snake_case     ,      _snake_case=7     ,      _snake_case=3     ,      _snake_case=30     ,      _snake_case=400     ,      _snake_case=True     ,      _snake_case=None     ,      _snake_case=True     ,      _snake_case=None     ,      _snake_case=None     ,      _snake_case=True     ,      _snake_case=1 / 255     ,      _snake_case=True     ,      _snake_case=FLAVA_IMAGE_MEAN     ,      _snake_case=FLAVA_IMAGE_STD     ,      _snake_case=14     ,      _snake_case=75     ,      _snake_case=None     ,      _snake_case=16     ,      _snake_case=0.3     ,      _snake_case=None     ,      _snake_case=True     ,      _snake_case=None     ,      _snake_case=None     ,      _snake_case=True     ,      _snake_case=None     ,      _snake_case=True     ,      _snake_case=True     ,      _snake_case=FLAVA_CODEBOOK_MEAN     ,      _snake_case=FLAVA_CODEBOOK_STD     ,      )				->					List[Any]:
								UpperCAmelCase_		:   Any													=       size if size is not None else {'height': 224, 'width': 224}
								UpperCAmelCase_		:   Any													=       crop_size if crop_size is not None else {'height': 224, 'width': 224}
								UpperCAmelCase_		:   Dict													=       codebook_size if codebook_size is not None else {'height': 112, 'width': 112}
								UpperCAmelCase_		:   Optional[Any]													=       codebook_crop_size if codebook_crop_size is not None else {'height': 112, 'width': 112}

								UpperCAmelCase_		:   str													=       parent
								UpperCAmelCase_		:   List[Any]													=       batch_size
								UpperCAmelCase_		:   str													=       num_channels
								UpperCAmelCase_		:   Optional[int]													=       do_resize
								UpperCAmelCase_		:   List[Any]													=       do_rescale
								UpperCAmelCase_		:   int													=       rescale_factor
								UpperCAmelCase_		:   List[Any]													=       min_resolution
								UpperCAmelCase_		:   Any													=       max_resolution
								UpperCAmelCase_		:   Optional[Any]													=       size
								UpperCAmelCase_		:   Optional[Any]													=       resample if resample is not None else PILImageResampling.BICUBIC
								UpperCAmelCase_		:   List[Any]													=       do_normalize
								UpperCAmelCase_		:   Dict													=       image_mean
								UpperCAmelCase_		:   List[Any]													=       image_std
								UpperCAmelCase_		:   str													=       do_center_crop
								UpperCAmelCase_		:   List[str]													=       crop_size

								UpperCAmelCase_		:   Tuple													=       input_size_patches
								UpperCAmelCase_		:   Optional[Any]													=       total_mask_patches
								UpperCAmelCase_		:   Optional[Any]													=       mask_group_max_patches
								UpperCAmelCase_		:   Any													=       mask_group_min_patches
								UpperCAmelCase_		:   Union[str, Any]													=       mask_group_min_aspect_ratio
								UpperCAmelCase_		:   List[str]													=       mask_group_max_aspect_ratio

								UpperCAmelCase_		:   Union[str, Any]													=       codebook_do_resize
								UpperCAmelCase_		:   Any													=       codebook_size
								UpperCAmelCase_		:   List[str]													=       codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
								UpperCAmelCase_		:   str													=       codebook_do_center_crop
								UpperCAmelCase_		:   Optional[int]													=       codebook_crop_size
								UpperCAmelCase_		:   List[str]													=       codebook_do_map_pixels
								UpperCAmelCase_		:   Optional[int]													=       codebook_do_normalize
								UpperCAmelCase_		:   Tuple													=       codebook_image_mean
								UpperCAmelCase_		:   Dict													=       codebook_image_std


							def     _snake_case				(      self)				->					List[Any]:
								return {
								    "image_mean": self.image_mean,
								    "image_std": self.image_std,
								    "do_normalize": self.do_normalize,
								    "do_resize": self.do_resize,
								    "size": self.size,
								    "resample": self.resample,
								    "do_rescale": self.do_rescale,
								    "rescale_factor": self.rescale_factor,
								    "do_center_crop": self.do_center_crop,
								    "crop_size": self.crop_size,
								    "input_size_patches": self.input_size_patches,
								    "total_mask_patches": self.total_mask_patches,
								    "mask_group_max_patches": self.mask_group_max_patches,
								    "mask_group_min_patches": self.mask_group_min_patches,
								    "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
								    "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,
								    "codebook_do_resize": self.codebook_do_resize,
								    "codebook_size": self.codebook_size,
								    "codebook_resample": self.codebook_resample,
								    "codebook_do_center_crop": self.codebook_do_center_crop,
								    "codebook_crop_size": self.codebook_crop_size,
								    "codebook_do_map_pixels": self.codebook_do_map_pixels,
								    "codebook_do_normalize": self.codebook_do_normalize,
								    "codebook_image_mean": self.codebook_image_mean,
								    "codebook_image_std": self.codebook_image_std,
								}


							def     _snake_case				(      self)				->					List[str]:
								return (self.size["height"], self.size["width"])


							def     _snake_case				(      self)				->					Tuple:
								return (
								    (self.input_size_patches, self.input_size_patches)
								    if not isinstance(self.input_size_patches     ,      _snake_case)
								    else self.input_size_patches
								)





							def     _snake_case				(      self)				->					Optional[int]:
								return (self.codebook_size["height"], self.codebook_size["width"])



@require_torch
@require_vision
class        lowercase    (	a_,       unittest.TestCase			):
							_lowerCamelCase		:   Optional[Any]= FlavaImageProcessor if is_vision_available() else None
							_lowerCamelCase		:   List[str]= None


							def     _snake_case				(      self)				->					List[Any]:
								UpperCAmelCase_		:   Any													=       FlavaImageProcessingTester(self)


							@property
							def     _snake_case				(      self)				->					int:
								return self.image_processor_tester.prepare_image_processor_dict()


							def     _snake_case				(      self)				->					Tuple:
								UpperCAmelCase_		:   Dict													=       self.image_processing_class(**self.image_processor_dict)
								self.assertTrue(hasattr(_snake_case     ,      'image_mean'))
								self.assertTrue(hasattr(_snake_case     ,      'image_std'))
								self.assertTrue(hasattr(_snake_case     ,      'do_normalize'))
								self.assertTrue(hasattr(_snake_case     ,      'do_resize'))
								self.assertTrue(hasattr(_snake_case     ,      'resample'))
								self.assertTrue(hasattr(_snake_case     ,      'crop_size'))
								self.assertTrue(hasattr(_snake_case     ,      'do_center_crop'))
								self.assertTrue(hasattr(_snake_case     ,      'do_rescale'))
								self.assertTrue(hasattr(_snake_case     ,      'rescale_factor'))
								self.assertTrue(hasattr(_snake_case     ,      'masking_generator'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_do_resize'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_size'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_resample'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_do_center_crop'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_crop_size'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_do_map_pixels'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_do_normalize'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_image_mean'))
								self.assertTrue(hasattr(_snake_case     ,      'codebook_image_std'))


							def     _snake_case				(      self)				->					str:
								UpperCAmelCase_		:   Any													=       self.image_processing_class.from_dict(self.image_processor_dict)
								self.assertEqual(image_processor.size     ,      {'height': 224, 'width': 224})
								self.assertEqual(image_processor.crop_size     ,      {'height': 224, 'width': 224})
								self.assertEqual(image_processor.codebook_size     ,      {'height': 112, 'width': 112})
								self.assertEqual(image_processor.codebook_crop_size     ,      {'height': 112, 'width': 112})

								UpperCAmelCase_		:   int													=       self.image_processing_class.from_dict(
								    self.image_processor_dict     ,      size=42     ,      crop_size=84     ,      codebook_size=33     ,      codebook_crop_size=66)
								self.assertEqual(image_processor.size     ,      {'height': 42, 'width': 42})
								self.assertEqual(image_processor.crop_size     ,      {'height': 84, 'width': 84})
								self.assertEqual(image_processor.codebook_size     ,      {'height': 33, 'width': 33})
								self.assertEqual(image_processor.codebook_crop_size     ,      {'height': 66, 'width': 66})


							def     _snake_case				(      self)				->					Optional[Any]:
								pass


							def     _snake_case				(      self)				->					int:
								# Initialize image_processing
								UpperCAmelCase_		:   Tuple													=       self.image_processing_class(**self.image_processor_dict)
								# create random PIL images
								UpperCAmelCase_		:   str													=       prepare_image_inputs(self.image_processor_tester     ,      equal_resolution=_snake_case)
								for image in image_inputs:
									self.assertIsInstance(_snake_case     ,      PIL.Image.Image)

								# Test not batched input
								UpperCAmelCase_		:   Union[str, Any]													=       image_processing(image_inputs[0]     ,      return_tensors='pt')

								# Test no bool masked pos
								self.assertFalse('bool_masked_pos' in encoded_images)

								UpperCAmelCase_						,     UpperCAmelCase_		:   List[str]													=       self.image_processor_tester.get_expected_image_size()

								self.assertEqual(
								    encoded_images.pixel_values.shape     ,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)     ,      )

								# Test batched
								UpperCAmelCase_		:   Tuple													=       image_processing(_snake_case     ,      return_tensors='pt')
								UpperCAmelCase_						,     UpperCAmelCase_		:   Optional[int]													=       self.image_processor_tester.get_expected_image_size()

								# Test no bool masked pos
								self.assertFalse('bool_masked_pos' in encoded_images)

								self.assertEqual(
								    encoded_images.pixel_values.shape     ,      (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        expected_height,
								        expected_width,
								    )     ,      )


							def     _snake_case				(      self     ,      _snake_case     ,      _snake_case)				->					int:
								# Initialize image_processing
								UpperCAmelCase_		:   List[str]													=       self.image_processing_class(**self.image_processor_dict)
								# create random tensors
								UpperCAmelCase_		:   int													=       prepare_image_inputs(self.image_processor_tester     ,      equal_resolution=_snake_case     ,      **_snake_case)
								for image in image_inputs:
									self.assertIsInstance(_snake_case     ,      _snake_case)

								# Test not batched input
								UpperCAmelCase_		:   List[Any]													=       image_processing(image_inputs[0]     ,      return_tensors='pt')

								UpperCAmelCase_						,     UpperCAmelCase_		:   Optional[int]													=       self.image_processor_tester.get_expected_image_size()
								self.assertEqual(
								    encoded_images.pixel_values.shape     ,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)     ,      )

								UpperCAmelCase_		:   Tuple													=       image_processing(_snake_case     ,      return_image_mask=_snake_case     ,      return_tensors='pt')

								UpperCAmelCase_						,     UpperCAmelCase_		:   List[Any]													=       self.image_processor_tester.get_expected_image_size()
								self.assertEqual(
								    encoded_images.pixel_values.shape     ,      (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        expected_height,
								        expected_width,
								    )     ,      )

								UpperCAmelCase_						,     UpperCAmelCase_		:   List[str]													=       self.image_processor_tester.get_expected_mask_size()
								self.assertEqual(
								    encoded_images.bool_masked_pos.shape     ,      (
								        self.image_processor_tester.batch_size,
								        expected_height,
								        expected_width,
								    )     ,      )

								# Test batched
								UpperCAmelCase_		:   Optional[Any]													=       image_processing(_snake_case     ,      return_tensors='pt').pixel_values

								UpperCAmelCase_						,     UpperCAmelCase_		:   List[str]													=       self.image_processor_tester.get_expected_image_size()
								self.assertEqual(
								    encoded_images.shape     ,      (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        expected_height,
								        expected_width,
								    )     ,      )

								# Test masking
								UpperCAmelCase_		:   int													=       image_processing(_snake_case     ,      return_image_mask=_snake_case     ,      return_tensors='pt')

								UpperCAmelCase_						,     UpperCAmelCase_		:   List[str]													=       self.image_processor_tester.get_expected_image_size()
								self.assertEqual(
								    encoded_images.pixel_values.shape     ,      (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        expected_height,
								        expected_width,
								    )     ,      )

								UpperCAmelCase_						,     UpperCAmelCase_		:   Any													=       self.image_processor_tester.get_expected_mask_size()
								self.assertEqual(
								    encoded_images.bool_masked_pos.shape     ,      (
								        self.image_processor_tester.batch_size,
								        expected_height,
								        expected_width,
								    )     ,      )


							def     _snake_case				(      self)				->					List[Any]:
								self._test_call_framework(np.ndarray     ,      prepare_kwargs={'numpify': True})


							def     _snake_case				(      self)				->					List[Any]:
								self._test_call_framework(torch.Tensor     ,      prepare_kwargs={'torchify': True})


							def     _snake_case				(      self)				->					str:
								# Initialize image_processing
								random.seed(1234)
								UpperCAmelCase_		:   int													=       self.image_processing_class(**self.image_processor_dict)
								UpperCAmelCase_		:   Optional[Any]													=       prepare_image_inputs(self.image_processor_tester     ,      equal_resolution=_snake_case     ,      torchify=_snake_case)

								# Test not batched input
								UpperCAmelCase_		:   List[str]													=       image_processing(image_inputs[0]     ,      return_image_mask=_snake_case     ,      return_tensors='pt')
								self.assertEqual(encoded_images.bool_masked_pos.sum().item()     ,      75)





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

								# Test not batched input
								UpperCAmelCase_		:   Optional[Any]													=       image_processing(image_inputs[0]     ,      return_codebook_pixels=_snake_case     ,      return_tensors='pt')
								UpperCAmelCase_						,     UpperCAmelCase_		:   Tuple													=       self.image_processor_tester.get_expected_codebook_image_size()
								self.assertEqual(
								    encoded_images.codebook_pixel_values.shape     ,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)     ,      )

								# Test batched
								UpperCAmelCase_		:   Optional[Any]													=       image_processing(_snake_case     ,      return_codebook_pixels=_snake_case     ,      return_tensors='pt')
								UpperCAmelCase_						,     UpperCAmelCase_		:   Any													=       self.image_processor_tester.get_expected_codebook_image_size()
								self.assertEqual(
								    encoded_images.codebook_pixel_values.shape     ,      (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        expected_height,
								        expected_width,
								    )     ,      )









'''simple docstring'''


import unittest

from transformers import is_torch_available, load_tool

from .test_tools_common import ToolTesterMixin


if is_torch_available():
						import torch



class        lowercase    (	unittest.TestCase,       a_			):


							def     _snake_case				(      self)				->					Optional[int]:
								UpperCAmelCase_		:   int													=       load_tool('speech-to-text')
								self.tool.setup()


							def     _snake_case				(      self)				->					Any:
								UpperCAmelCase_		:   str													=       self.tool(torch.ones(3000))
								self.assertEqual(_snake_case     ,      ' you')





							def     _snake_case				(      self)				->					str:
								UpperCAmelCase_		:   List[Any]													=       self.tool(audio=torch.ones(3000))
								self.assertEqual(_snake_case     ,      ' you')






