


"""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


if is_torch_available():
			import torch

if is_vision_available():
			from PIL import Image

			from transformers import CLIPImageProcessor



class      _UpperCAmelCase					(				unittest.TestCase							):






		'''simple docstring'''

		def __init__(self							,			a_							,			a_=7							,			a_=3							,			a_=18							,			a_=30							,			a_=4_00							,			a_=True							,			a_=None							,			a_=True							,			a_=None							,			a_=True							,			a_=[0.4814_5466, 0.457_8275, 0.4082_1073]							,			a_=[0.2686_2954, 0.2613_0258, 0.2757_7711]							,			a_=True							,			):





			'''simple docstring'''

			__snake_case      :		Any         =							size if size is not None else {'''shortest_edge''': 20}
			__snake_case      :		Optional[int]         =							crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
			__snake_case      :		Dict         =							parent
			__snake_case      :		List[Any]         =							batch_size
			__snake_case      :		str         =							num_channels
			__snake_case      :		Optional[int]         =							image_size
			__snake_case      :		Any         =							min_resolution
			__snake_case      :		Tuple         =							max_resolution
			__snake_case      :		Optional[int]         =							do_resize
			__snake_case      :		int         =							size
			__snake_case      :		int         =							do_center_crop
			__snake_case      :		Optional[Any]         =							crop_size
			__snake_case      :		Union[str, Any]         =							do_normalize
			__snake_case      :		Optional[int]         =							image_mean
			__snake_case      :		Optional[Any]         =							image_std
			__snake_case      :		Optional[int]         =							do_convert_rgb



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			return {
			    "do_resize": self.do_resize,
			    "size": self.size,
			    "do_center_crop": self.do_center_crop,
			    "crop_size": self.crop_size,
			    "do_normalize": self.do_normalize,
			    "image_mean": self.image_mean,
			    "image_std": self.image_std,
			    "do_convert_rgb": self.do_convert_rgb,
			}



		def 							SCREAMING_SNAKE_CASE    (self							,			a_=False							,			a_=False							,			a_=False   ):





			'''simple docstring'''

			assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

			if equal_resolution:
				__snake_case      :		Dict         =							[]
				for i in range(self.batch_size   ):
					image_inputs.append(
					    np.random.randint(
					        2_55							,			size=(self.num_channels, self.max_resolution, self.max_resolution)							,			dtype=np.uinta   )   )
			else:
				__snake_case      :		List[str]         =							[]
				for i in range(self.batch_size   ):
					__snake_case      ,				__snake_case      :		Dict         =							np.random.choice(np.arange(self.min_resolution							,			self.max_resolution   )							,			2   )
					image_inputs.append(np.random.randint(2_55							,			size=(self.num_channels, width, height)							,			dtype=np.uinta   )   )

			if not numpify and not torchify:
				# PIL expects the channel dimension as last dimension
				__snake_case      :		Dict         =							[Image.fromarray(np.moveaxis(a_							,			0							,			-1   )   ) for x in image_inputs]

			if torchify:
				__snake_case      :		Dict         =							[torch.from_numpy(a_   ) for x in image_inputs]

			return image_inputs



@require_torch
@require_vision
class      _UpperCAmelCase					(				__snake_case,							unittest.TestCase							):






		'''simple docstring'''

		lowerCamelCase__           =CLIPImageProcessor if is_vision_available() else None



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		int         =							CLIPImageProcessingTester(self   )



		@property
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			return self.image_processor_tester.prepare_image_processor_dict()



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		int         =							self.image_processing_class(**self.image_processor_dict   )
			self.assertTrue(hasattr(a_							,			'''do_resize'''   )   )
			self.assertTrue(hasattr(a_							,			'''size'''   )   )
			self.assertTrue(hasattr(a_							,			'''do_center_crop'''   )   )
			self.assertTrue(hasattr(a_							,			'''center_crop'''   )   )
			self.assertTrue(hasattr(a_							,			'''do_normalize'''   )   )
			self.assertTrue(hasattr(a_							,			'''image_mean'''   )   )
			self.assertTrue(hasattr(a_							,			'''image_std'''   )   )
			self.assertTrue(hasattr(a_							,			'''do_convert_rgb'''   )   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Any         =							self.image_processing_class.from_dict(self.image_processor_dict   )
			self.assertEqual(image_processor.size							,			{'''shortest_edge''': 20}   )
			self.assertEqual(image_processor.crop_size							,			{'''height''': 18, '''width''': 18}   )

			__snake_case      :		int         =							self.image_processing_class.from_dict(self.image_processor_dict							,			size=42							,			crop_size=84   )
			self.assertEqual(image_processor.size							,			{'''shortest_edge''': 42}   )
			self.assertEqual(image_processor.crop_size							,			{'''height''': 84, '''width''': 84}   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			pass



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Optional[Any]         =							self.image_processing_class(**self.image_processor_dict   )
			# create random PIL images
			__snake_case      :		Tuple         =							self.image_processor_tester.prepare_inputs(equal_resolution=a_   )
			for image in image_inputs:
				self.assertIsInstance(a_							,			Image.Image   )

			# Test not batched input
			__snake_case      :		Union[str, Any]         =							image_processing(image_inputs[0]							,			return_tensors='''pt'''   ).pixel_values
			self.assertEqual(
			    encoded_images.shape							,			(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['''height'''],
			        self.image_processor_tester.crop_size['''width'''],
			    )							,			)

			# Test batched
			__snake_case      :		str         =							image_processing(a_							,			return_tensors='''pt'''   ).pixel_values
			self.assertEqual(
			    encoded_images.shape							,			(
			        self.image_processor_tester.batch_size,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['''height'''],
			        self.image_processor_tester.crop_size['''width'''],
			    )							,			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Optional[Any]         =							self.image_processing_class(**self.image_processor_dict   )
			# create random numpy tensors
			__snake_case      :		int         =							self.image_processor_tester.prepare_inputs(equal_resolution=a_							,			numpify=a_   )
			for image in image_inputs:
				self.assertIsInstance(a_							,			np.ndarray   )

			# Test not batched input
			__snake_case      :		Optional[Any]         =							image_processing(image_inputs[0]							,			return_tensors='''pt'''   ).pixel_values
			self.assertEqual(
			    encoded_images.shape							,			(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['''height'''],
			        self.image_processor_tester.crop_size['''width'''],
			    )							,			)

			# Test batched
			__snake_case      :		Union[str, Any]         =							image_processing(a_							,			return_tensors='''pt'''   ).pixel_values
			self.assertEqual(
			    encoded_images.shape							,			(
			        self.image_processor_tester.batch_size,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['''height'''],
			        self.image_processor_tester.crop_size['''width'''],
			    )							,			)



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		str         =							self.image_processing_class(**self.image_processor_dict   )
			# create random PyTorch tensors
			__snake_case      :		List[Any]         =							self.image_processor_tester.prepare_inputs(equal_resolution=a_							,			torchify=a_   )
			for image in image_inputs:
				self.assertIsInstance(a_							,			torch.Tensor   )

			# Test not batched input
			__snake_case      :		str         =							image_processing(image_inputs[0]							,			return_tensors='''pt'''   ).pixel_values
			self.assertEqual(
			    encoded_images.shape							,			(
			        1,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['''height'''],
			        self.image_processor_tester.crop_size['''width'''],
			    )							,			)

			# Test batched
			__snake_case      :		Any         =							image_processing(a_							,			return_tensors='''pt'''   ).pixel_values
			self.assertEqual(
			    encoded_images.shape							,			(
			        self.image_processor_tester.batch_size,
			        self.image_processor_tester.num_channels,
			        self.image_processor_tester.crop_size['''height'''],
			        self.image_processor_tester.crop_size['''width'''],
			    )							,			)



@require_torch
@require_vision
class      _UpperCAmelCase					(				__snake_case,							unittest.TestCase							):






		'''simple docstring'''

		lowerCamelCase__           =CLIPImageProcessor if is_vision_available() else None



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		List[str]         =							CLIPImageProcessingTester(self							,			num_channels=4   )
			__snake_case      :		Optional[Any]         =							3



		@property
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			return self.image_processor_tester.prepare_image_processor_dict()



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Union[str, Any]         =							self.image_processing_class(**self.image_processor_dict   )
			self.assertTrue(hasattr(a_							,			'''do_resize'''   )   )
			self.assertTrue(hasattr(a_							,			'''size'''   )   )
			self.assertTrue(hasattr(a_							,			'''do_center_crop'''   )   )
			self.assertTrue(hasattr(a_							,			'''center_crop'''   )   )
			self.assertTrue(hasattr(a_							,			'''do_normalize'''   )   )
			self.assertTrue(hasattr(a_							,			'''image_mean'''   )   )
			self.assertTrue(hasattr(a_							,			'''image_std'''   )   )
			self.assertTrue(hasattr(a_							,			'''do_convert_rgb'''   )   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			pass



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Tuple         =							self.image_processing_class(**self.image_processor_dict   )
			# create random PIL images
			__snake_case      :		Optional[Any]         =							self.image_processor_tester.prepare_inputs(equal_resolution=a_   )
			for image in image_inputs:
				self.assertIsInstance(a_							,			Image.Image   )

			# Test not batched input
			__snake_case      :		int         =							image_processing(image_inputs[0]							,			return_tensors='''pt'''   ).pixel_values
			self.assertEqual(
			    encoded_images.shape							,			(
			        1,
			        self.expected_encoded_image_num_channels,
			        self.image_processor_tester.crop_size['''height'''],
			        self.image_processor_tester.crop_size['''width'''],
			    )							,			)

			# Test batched
			__snake_case      :		Optional[int]         =							image_processing(a_							,			return_tensors='''pt'''   ).pixel_values
			self.assertEqual(
			    encoded_images.shape							,			(
			        self.image_processor_tester.batch_size,
			        self.expected_encoded_image_num_channels,
			        self.image_processor_tester.crop_size['''height'''],
			        self.image_processor_tester.crop_size['''width'''],
			    )							,			)










import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
 import torch


__snake_case		:Any 						=	random.Random()





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase=1.0  ,					_UpperCAmelCase=None  ,					_UpperCAmelCase=None							):
    if rng is None:
        __a					=							global_rng

    __a					=							[]
    for batch_idx in range(shape[0]							):
        values.append([]							)
        for _ in range(shape[1]							):
            values[-1].append(rng.random() * scale							)

    return values

@require_torch
class        _A			(      unittest.TestCase       ):



       def __init__(						self				:	Dict	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	Tuple=7	,						__SCREAMING_SNAKE_CASE				:	Any=400	,						__SCREAMING_SNAKE_CASE				:	Any=2_000	,						__SCREAMING_SNAKE_CASE				:	int=1	,						__SCREAMING_SNAKE_CASE				:	Dict=0.0	,						__SCREAMING_SNAKE_CASE				:	Optional[int]=24_000	,						__SCREAMING_SNAKE_CASE				:	Dict=True	,						):


           '''simple docstring'''

           __a					=							parent
           __a					=							batch_size
           __a					=							min_seq_length
           __a					=							max_seq_length
           __a					=							(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
           __a					=							feature_size
           __a					=							padding_value
           __a					=							sampling_rate
           __a					=							return_attention_mask



       def 						_lowerCamelCase     (						self				:	List[str]):


           '''simple docstring'''

           return {
               "feature_size": self.feature_size,
               "padding_value": self.padding_value,
               "sampling_rate": self.sampling_rate,
               "return_attention_mask": self.return_attention_mask,
           }





       def 						_lowerCamelCase     (						self				:	List[Any]	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]=False	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]=False):


           '''simple docstring'''

           def _flatten(__SCREAMING_SNAKE_CASE				:	List[str]):
               return list(itertools.chain(*__SCREAMING_SNAKE_CASE))

           if equal_length:
               __a					=							floats_list((self.batch_size, self.max_seq_length))
           else:
               # make sure that inputs increase in size
               __a					=							[
                   _flatten(floats_list((x, self.feature_size)))
                   for x in range(self.min_seq_length	,						self.max_seq_length	,						self.seq_length_diff)
               ]

           if numpify:
               __a					=							[np.asarray(__SCREAMING_SNAKE_CASE) for x in audio_inputs]

           return audio_inputs


@require_torch
class        _A			(      __UpperCAmelCase ,unittest.TestCase       ):
       UpperCamelCase__    :       str		   =		EncodecFeatureExtractor



       def 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           __a					=							EnCodecFeatureExtractionTester(self)



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

           __a					=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
           # create three inputs of length 800, 1000, and 1200
           __a					=							[floats_list((1, x))[0] for x in range(800	,						1_400	,						200)]
           __a					=							[np.asarray(__SCREAMING_SNAKE_CASE) for audio_input in audio_inputs]

           # Test not batched input
           __a					=							feat_extract(audio_inputs[0]	,						return_tensors='''np''').input_values
           __a					=							feat_extract(np_audio_inputs[0]	,						return_tensors='''np''').input_values
           self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						atol=1E-3))

           # Test batched
           __a					=							feat_extract(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''np''').input_values
           __a					=							feat_extract(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''np''').input_values
           for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE):
               self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						atol=1E-3))



       def 						_lowerCamelCase     (						self				:	Optional[Any]):


           '''simple docstring'''

           __a					=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
           __a					=							np.random.rand(100).astype(np.floataa)
           __a					=							np_audio_inputs.tolist()

           for inputs in [py_audio_inputs, np_audio_inputs]:
               __a					=							feature_extractor.pad([{'''input_values''': inputs}]	,						return_tensors='''np''')
               self.assertTrue(np_processed.input_values.dtype == np.floataa)
               __a					=							feature_extractor.pad([{'''input_values''': inputs}]	,						return_tensors='''pt''')
               self.assertTrue(pt_processed.input_values.dtype == torch.floataa)



       def 						_lowerCamelCase     (						self				:	Tuple	,						__SCREAMING_SNAKE_CASE				:	str):


           '''simple docstring'''

           from datasets import load_dataset

           __a					=							load_dataset('''hf-internal-testing/librispeech_asr_dummy'''	,						'''clean'''	,						split='''validation''')
           # automatic decoding with librispeech
           __a					=							ds.sort('''id''').select(range(__SCREAMING_SNAKE_CASE))[:num_samples]['''audio''']

           return [x["array"] for x in audio_samples]



       def 						_lowerCamelCase     (						self				:	int):


           '''simple docstring'''

           __a					=							torch.tensor(
               [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
                3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
                2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
                4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
                7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
                4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03])
           # fmt: on
           __a					=							self._load_datasamples(1)
           __a					=							EncodecFeatureExtractor()
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(input_values.shape	,						(1, 1, 93_680))
           self.assertTrue(torch.allclose(input_values[0, 0, :30]	,						__SCREAMING_SNAKE_CASE	,						atol=1E-6))



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

           __a					=							torch.tensor(
               [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
                3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
                2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
                4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
                7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
                4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03])
           # fmt: on
           __a					=							self._load_datasamples(1)
           __a					=							[np.tile(input_audio[0][None]	,						reps=(2, 1))]
           input_audio[0][1] *= 0.5
           __a					=							EncodecFeatureExtractor(feature_size=2)
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(input_values.shape	,						(1, 2, 93_680))
           self.assertTrue(torch.allclose(input_values[0, 0, :30]	,						__SCREAMING_SNAKE_CASE	,						atol=1E-6))
           self.assertTrue(torch.allclose(input_values[0, 1, :30]	,						EXPECTED_INPUT_VALUES * 0.5	,						atol=1E-6))





       def 						_lowerCamelCase     (						self				:	Any):


           '''simple docstring'''

           __a					=							self._load_datasamples(2)
           # would be easier if the stride was like
           __a					=							EncodecFeatureExtractor(feature_size=1	,						chunk_length_s=1	,						overlap=0.01)

           # pad and trunc raise an error ?
           with self.assertRaisesRegex(
               __SCREAMING_SNAKE_CASE	,						'''^Both padding and truncation were set. Make sure you only set one.$'''	,						):
               __a					=							feature_extractor(
                   __SCREAMING_SNAKE_CASE	,						padding='''max_length'''	,						truncation=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values

           # truncate to chunk
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						truncation=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(2, 1, 71_520))  # 2 chunks

           # force truncate to max_length
           __a					=							feature_extractor(
               __SCREAMING_SNAKE_CASE	,						truncation=__SCREAMING_SNAKE_CASE	,						max_length=48_000	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(2, 1, 48_000))

           # pad to chunk
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(padded_outputs.shape	,						(2, 1, 95_280))

           # pad to chunk
           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(2, 1, 95_280))

           # force pad to max length
           __a					=							feature_extractor(
               __SCREAMING_SNAKE_CASE	,						padding='''max_length'''	,						max_length=100_000	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(2, 1, 100_000))

           # force no pad
           with self.assertRaisesRegex(
               __SCREAMING_SNAKE_CASE	,						'''^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'''	,						):
               __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values

           __a					=							feature_extractor(input_audio[0]	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(1, 1, 93_680))

           # no pad if no chunk_length_s
           __a					=							None
           with self.assertRaisesRegex(
               __SCREAMING_SNAKE_CASE	,						'''^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'''	,						):
               __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values

           __a					=							feature_extractor(input_audio[0]	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(1, 1, 93_680))

           # no pad if no overlap
           __a					=							2
           __a					=							None
           with self.assertRaisesRegex(
               __SCREAMING_SNAKE_CASE	,						'''^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'''	,						):
               __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values

           __a					=							feature_extractor(input_audio[0]	,						padding=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').input_values
           self.assertEquals(truncated_outputs.shape	,						(1, 1, 93_680))





