






"""simple docstring"""


import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
       from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

       from .test_feature_extraction_speechta import floats_list


lowercase_								=	get_tests_dir('fixtures/test_sentencepiece_bpe_char.model')


@require_torch
class    snake_case						(				unittest.TestCase		):


   '''simple docstring'''

   def 							_SCREAMING_SNAKE_CASE							(      self					:	str    ):

     '''simple docstring'''
     __A		     =					tempfile.mkdtemp()

     __A		     =					SpeechTaTokenizer(_lowerCamelCase    )
     tokenizer.save_pretrained(self.tmpdirname    )

     __A		     =					{
         '''feature_size''': 1,
         '''padding_value''': 0.0,
         '''sampling_rate''': 1_60_00,
         '''do_normalize''': False,
         '''num_mel_bins''': 80,
         '''hop_length''': 16,
         '''win_length''': 64,
         '''win_function''': '''hann_window''',
         '''fmin''': 80,
         '''fmax''': 76_00,
         '''mel_floor''': 1e-10,
         '''reduction_factor''': 2,
         '''return_attention_mask''': True,
     }

     __A		     =					os.path.join(self.tmpdirname,			_lowerCamelCase    )
     with open(self.feature_extraction_file,			'''w''',			encoding='''utf-8'''    ) as fp:
       fp.write(json.dumps(_lowerCamelCase    ) + '''\n'''    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Tuple,			**_lowerCamelCase					:	Optional[int]    ):

     '''simple docstring'''
     return SpeechTaTokenizer.from_pretrained(self.tmpdirname,			**_lowerCamelCase    )


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

     '''simple docstring'''
     return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname,			**_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int]    ):

     '''simple docstring'''
     shutil.rmtree(self.tmpdirname    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict    ):

     '''simple docstring'''
     __A		     =					self.get_tokenizer()
     __A		     =					self.get_feature_extractor()

     __A		     =					SpeechTaProcessor(tokenizer=_lowerCamelCase,			feature_extractor=_lowerCamelCase    )

     processor.save_pretrained(self.tmpdirname    )
     __A		     =					SpeechTaProcessor.from_pretrained(self.tmpdirname    )

     self.assertEqual(processor.tokenizer.get_vocab(),			tokenizer.get_vocab()    )
     self.assertIsInstance(processor.tokenizer,			_lowerCamelCase    )

     self.assertEqual(processor.feature_extractor.to_json_string(),			feature_extractor.to_json_string()    )
     self.assertIsInstance(processor.feature_extractor,			_lowerCamelCase    )


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

     '''simple docstring'''
     __A		     =					SpeechTaProcessor(tokenizer=self.get_tokenizer(),			feature_extractor=self.get_feature_extractor()    )
     processor.save_pretrained(self.tmpdirname    )

     __A		     =					self.get_tokenizer(bos_token='''(BOS)''',			eos_token='''(EOS)'''    )
     __A		     =					self.get_feature_extractor(do_normalize=_lowerCamelCase,			padding_value=1.0    )

     __A		     =					SpeechTaProcessor.from_pretrained(
         self.tmpdirname,			bos_token='''(BOS)''',			eos_token='''(EOS)''',			do_normalize=_lowerCamelCase,			padding_value=1.0    )

     self.assertEqual(processor.tokenizer.get_vocab(),			tokenizer_add_kwargs.get_vocab()    )
     self.assertIsInstance(processor.tokenizer,			_lowerCamelCase    )

     self.assertEqual(processor.feature_extractor.to_json_string(),			feature_extractor_add_kwargs.to_json_string()    )
     self.assertIsInstance(processor.feature_extractor,			_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any]    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					SpeechTaProcessor(tokenizer=_lowerCamelCase,			feature_extractor=_lowerCamelCase    )

     __A		     =					floats_list((3, 10_00)    )

     __A		     =					feature_extractor(audio=_lowerCamelCase,			return_tensors='''np'''    )
     __A		     =					processor(audio=_lowerCamelCase,			return_tensors='''np'''    )

     for key in input_feat_extract.keys():
       self.assertAlmostEqual(input_feat_extract[key].sum(),			input_processor[key].sum(),			delta=1e-2    )


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

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					SpeechTaProcessor(tokenizer=_lowerCamelCase,			feature_extractor=_lowerCamelCase    )

     __A		     =					floats_list((3, 10_00)    )

     __A		     =					feature_extractor(audio_target=_lowerCamelCase,			return_tensors='''np'''    )
     __A		     =					processor(audio_target=_lowerCamelCase,			return_tensors='''np'''    )

     for key in input_feat_extract.keys():
       self.assertAlmostEqual(input_feat_extract[key].sum(),			input_processor[key].sum(),			delta=1e-2    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Tuple    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					SpeechTaProcessor(tokenizer=_lowerCamelCase,			feature_extractor=_lowerCamelCase    )

     __A		     =					'''This is a test string'''

     __A		     =					processor(text=_lowerCamelCase    )
     __A		     =					tokenizer(_lowerCamelCase    )

     for key in encoded_tok.keys():
       self.assertListEqual(encoded_tok[key],			encoded_processor[key]    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any]    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					SpeechTaProcessor(tokenizer=_lowerCamelCase,			feature_extractor=_lowerCamelCase    )

     __A		     =					'''This is a test string'''

     __A		     =					processor(text_target=_lowerCamelCase    )
     __A		     =					tokenizer(_lowerCamelCase    )

     for key in encoded_tok.keys():
       self.assertListEqual(encoded_tok[key],			encoded_processor[key]    )


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

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					SpeechTaProcessor(tokenizer=_lowerCamelCase,			feature_extractor=_lowerCamelCase    )

     __A		     =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     __A		     =					processor.batch_decode(_lowerCamelCase    )
     __A		     =					tokenizer.batch_decode(_lowerCamelCase    )

     self.assertListEqual(_lowerCamelCase,			_lowerCamelCase    )






   def 							_SCREAMING_SNAKE_CASE							(      self					:	str    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					SpeechTaProcessor(tokenizer=_lowerCamelCase,			feature_extractor=_lowerCamelCase    )

     self.assertListEqual(
         processor.model_input_names,			feature_extractor.model_input_names,			msg='''`processor` and `feature_extractor` model input names do not match''',			)











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






class    _UpperCAmelCase  (      unittest.TestCase					):


					def __init__(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :Dict=7	,			__UpperCamelCase     :Optional[Any]=3	,			__UpperCamelCase     :Tuple=18	,			__UpperCamelCase     :List[Any]=30	,			__UpperCamelCase     :Optional[Any]=4_00	,			__UpperCamelCase     :Union[str, Any]=True	,			__UpperCamelCase     :Tuple=None	,			__UpperCamelCase     :List[str]=True	,			__UpperCamelCase     :Any=False	,			__UpperCamelCase     :str=[0.48_145_466, 0.4_578_275, 0.40_821_073]	,			__UpperCamelCase     :Optional[Any]=[0.26_862_954, 0.26_130_258, 0.27_577_711]	,			__UpperCamelCase     :Optional[Any]=True	,			):
												A						=    size if size is not None else {"height": 20, "width": 20}
												A						=    parent
												A						=    batch_size
												A						=    num_channels
												A						=    image_size
												A						=    min_resolution
												A						=    max_resolution
												A						=    do_resize
												A						=    size
												A						=    do_normalize
												A						=    image_mean
												A						=    image_std
												A						=    do_pad
												A						=    do_convert_rgb


					def       lowerCamelCase			(   self     :List[str]						):
												return {
												    "do_resize": self.do_resize,
												    "size": self.size,
												    "do_normalize": self.do_normalize,
												    "image_mean": self.image_mean,
												    "image_std": self.image_std,
												    "do_convert_rgb": self.do_convert_rgb,
												    "do_pad": self.do_pad,
												}


					def       lowerCamelCase			(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[int]=False	,			__UpperCamelCase     :Dict=False	,			__UpperCamelCase     :Dict=False						):
												assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

												if equal_resolution:
																			A						=    []
																			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:
																			A						=    []
																			for i in range(self.batch_size						):
																										A,      A						=    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
																			A						=    [Image.fromarray(np.moveaxis(__UpperCamelCase	,			0	,			-1						)						) for x in image_inputs]

												if torchify:
																			A						=    [torch.from_numpy(__UpperCamelCase						) for x in image_inputs]

												return image_inputs







@require_torch
@require_vision
class    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				BlipImageProcessor if is_vision_available() else None


					def       lowerCamelCase			(   self     :Optional[Any]						):
												A						=    BlipImageProcessingTester(self						)


					@property
					def       lowerCamelCase			(   self     :List[str]						):
												return self.image_processor_tester.prepare_image_processor_dict()


					def       lowerCamelCase			(   self     :Any						):
												A						=    self.image_processing_class(**self.image_processor_dict						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_resize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"size"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_normalize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_mean"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_std"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_convert_rgb"						)						)


					def       lowerCamelCase			(   self     :List[Any]						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PIL images
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			Image.Image						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			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.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


					def       lowerCamelCase			(   self     :Union[str, Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random numpy tensors
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase	,			numpify=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			np.ndarray						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			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.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


					def       lowerCamelCase			(   self     :Tuple						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PyTorch tensors
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase	,			torchify=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			torch.Tensor						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			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.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)







@require_torch
@require_vision
class    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				BlipImageProcessor if is_vision_available() else None


					def       lowerCamelCase			(   self     :int						):
												A						=    BlipImageProcessingTester(self	,			num_channels=4						)
												A						=    3


					@property
					def       lowerCamelCase			(   self     :Optional[Any]						):
												return self.image_processor_tester.prepare_image_processor_dict()


					def       lowerCamelCase			(   self     :int						):
												A						=    self.image_processing_class(**self.image_processor_dict						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_resize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"size"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_normalize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_mean"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_std"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_convert_rgb"						)						)


					def       lowerCamelCase			(   self     :Any						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PIL images
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			Image.Image						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.expected_encoded_image_num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			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.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


