



'''simple docstring'''
import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


snake_case_					:      Optional[int]    			=    get_tests_dir('fixtures/test_sentencepiece.model')


if is_torch_available():
					from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

snake_case_					:      Union[str, Any]    			=    256047
snake_case_					:      int    			=    256145






@require_sentencepiece
@require_tokenizers
class 				lowercase__      (				lowercase		,   unittest.TestCase  ):
	lowercase__    							=     NllbTokenizer
	lowercase__    							=     NllbTokenizerFast
	lowercase__    							=     True
	lowercase__    							=     True
	lowercase__    							=     {}





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







							'''simple docstring'''
							super().setUp()

							# We have a SentencePiece fixture for testing
							_UpperCamelCase   :						Optional[int]												=  NllbTokenizer(lowerCamelCase__					,keep_accents=lowerCamelCase__					)
							tokenizer.save_pretrained(self.tmpdirname					)





	def       UpperCamelCase_    (					self   :							str					):







							'''simple docstring'''
							_UpperCamelCase   :						Union[str, Any]												=  NllbTokenizer(lowerCamelCase__					,keep_accents=lowerCamelCase__					)

							_UpperCamelCase   :						Dict												=  tokenizer.tokenize('This is a test'					)
							self.assertListEqual(lowerCamelCase__					,['▁This', '▁is', '▁a', '▁t', 'est']					)

							self.assertListEqual(
							    tokenizer.convert_tokens_to_ids(lowerCamelCase__					)					,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]					,)

							_UpperCamelCase   :						Optional[int]												=  tokenizer.tokenize('I was born in 92000, and this is falsé.'					)
							self.assertListEqual(
							    lowerCamelCase__					,[
							        SPIECE_UNDERLINE + 'I',
							        SPIECE_UNDERLINE + 'was',
							        SPIECE_UNDERLINE + 'b',
							        'or',
							        'n',
							        SPIECE_UNDERLINE + 'in',
							        SPIECE_UNDERLINE + '',
							        '9',
							        '2',
							        '0',
							        '0',
							        '0',
							        ',',
							        SPIECE_UNDERLINE + 'and',
							        SPIECE_UNDERLINE + 'this',
							        SPIECE_UNDERLINE + 'is',
							        SPIECE_UNDERLINE + 'f',
							        'al',
							        's',
							        'é',
							        '.',
							    ]					,)
							_UpperCamelCase   :						Optional[Any]												=  tokenizer.convert_tokens_to_ids(lowerCamelCase__					)
							self.assertListEqual(
							    lowerCamelCase__					,[
							        value + tokenizer.fairseq_offset
							        for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
							    ]					,)

							_UpperCamelCase   :						List[str]												=  tokenizer.convert_ids_to_tokens(lowerCamelCase__					)
							self.assertListEqual(
							    lowerCamelCase__					,[
							        SPIECE_UNDERLINE + 'I',
							        SPIECE_UNDERLINE + 'was',
							        SPIECE_UNDERLINE + 'b',
							        'or',
							        'n',
							        SPIECE_UNDERLINE + 'in',
							        SPIECE_UNDERLINE + '',
							        '<unk>',
							        '2',
							        '0',
							        '0',
							        '0',
							        ',',
							        SPIECE_UNDERLINE + 'and',
							        SPIECE_UNDERLINE + 'this',
							        SPIECE_UNDERLINE + 'is',
							        SPIECE_UNDERLINE + 'f',
							        'al',
							        's',
							        '<unk>',
							        '.',
							    ]					,)





	def       UpperCamelCase_    (					self   :							int					):







							'''simple docstring'''
							_UpperCamelCase   :						Tuple												=  (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-nllb', {})
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'					):
																			_UpperCamelCase   :						str												=  self.rust_tokenizer_class.from_pretrained(lowerCamelCase__					,**lowerCamelCase__					)
																			_UpperCamelCase   :						Tuple												=  self.tokenizer_class.from_pretrained(lowerCamelCase__					,**lowerCamelCase__					)

																			_UpperCamelCase   :						Tuple												=  tempfile.mkdtemp()

																			_UpperCamelCase   :						List[Any]												=  tokenizer_r.save_pretrained(lowerCamelCase__					)
																			_UpperCamelCase   :						Dict												=  tokenizer_p.save_pretrained(lowerCamelCase__					)

																			# Checks it save with the same files + the tokenizer.json file for the fast one
																			self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files					)					)
																			_UpperCamelCase   :						Optional[Any]												=  tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f					)
																			self.assertSequenceEqual(lowerCamelCase__					,lowerCamelCase__					)

																			# Checks everything loads correctly in the same way
																			_UpperCamelCase   :						Optional[Any]												=  tokenizer_r.from_pretrained(lowerCamelCase__					)
																			_UpperCamelCase   :						int												=  tokenizer_p.from_pretrained(lowerCamelCase__					)

																			# Check special tokens are set accordingly on Rust and Python
																			for key in tokenizer_pp.special_tokens_map:
																									self.assertTrue(hasattr(lowerCamelCase__					,lowerCamelCase__					)					)

																			shutil.rmtree(lowerCamelCase__					)

																			# Save tokenizer rust, legacy_format=True
																			_UpperCamelCase   :						Any												=  tempfile.mkdtemp()

																			_UpperCamelCase   :						Tuple												=  tokenizer_r.save_pretrained(lowerCamelCase__					,legacy_format=lowerCamelCase__					)
																			_UpperCamelCase   :						Optional[Any]												=  tokenizer_p.save_pretrained(lowerCamelCase__					)

																			# Checks it save with the same files
																			self.assertSequenceEqual(lowerCamelCase__					,lowerCamelCase__					)

																			# Checks everything loads correctly in the same way
																			_UpperCamelCase   :						str												=  tokenizer_r.from_pretrained(lowerCamelCase__					)
																			_UpperCamelCase   :						int												=  tokenizer_p.from_pretrained(lowerCamelCase__					)

																			# Check special tokens are set accordingly on Rust and Python
																			for key in tokenizer_pp.special_tokens_map:
																									self.assertTrue(hasattr(lowerCamelCase__					,lowerCamelCase__					)					)

																			shutil.rmtree(lowerCamelCase__					)

																			# Save tokenizer rust, legacy_format=False
																			_UpperCamelCase   :						Tuple												=  tempfile.mkdtemp()

																			_UpperCamelCase   :						List[Any]												=  tokenizer_r.save_pretrained(lowerCamelCase__					,legacy_format=lowerCamelCase__					)
																			_UpperCamelCase   :						int												=  tokenizer_p.save_pretrained(lowerCamelCase__					)

																			# Checks it saved the tokenizer.json file
																			self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files					)					)

																			# Checks everything loads correctly in the same way
																			_UpperCamelCase   :						int												=  tokenizer_r.from_pretrained(lowerCamelCase__					)
																			_UpperCamelCase   :						Optional[Any]												=  tokenizer_p.from_pretrained(lowerCamelCase__					)

																			# Check special tokens are set accordingly on Rust and Python
																			for key in tokenizer_pp.special_tokens_map:
																									self.assertTrue(hasattr(lowerCamelCase__					,lowerCamelCase__					)					)

																			shutil.rmtree(lowerCamelCase__					)





	@require_torch
	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							if not self.test_seqaseq:
													return

							_UpperCamelCase   :						Optional[Any]												=  self.get_tokenizers()
							for tokenizer in tokenizers:
													with self.subTest(F'{tokenizer.__class__.__name__}'					):
																			# Longer text that will definitely require truncation.
																			_UpperCamelCase   :						int												=  [
																			    ' UN Chief Says There Is No Military Solution in Syria',
																			    ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for'
																			    ' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons'
																			    ' will only worsen the violence and misery for millions of people.',
																			]
																			_UpperCamelCase   :						Tuple												=  [
																			    'Şeful ONU declară că nu există o soluţie militară în Siria',
																			    'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al'
																			    ' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi'
																			    ' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
																			]
																			try:
																									_UpperCamelCase   :						Optional[Any]												=  tokenizer.prepare_seqaseq_batch(
																									    src_texts=lowerCamelCase__					,tgt_texts=lowerCamelCase__					,max_length=3					,max_target_length=10					,return_tensors='pt'					,src_lang='eng_Latn'					,tgt_lang='ron_Latn'					,)
																			except NotImplementedError:
																									return
																			self.assertEqual(batch.input_ids.shape[1]					,3					)
																			self.assertEqual(batch.labels.shape[1]					,10					)
																			# max_target_length will default to max_length if not specified
																			_UpperCamelCase   :						Dict												=  tokenizer.prepare_seqaseq_batch(
																			    lowerCamelCase__					,tgt_texts=lowerCamelCase__					,max_length=3					,return_tensors='pt'					)
																			self.assertEqual(batch.input_ids.shape[1]					,3					)
																			self.assertEqual(batch.labels.shape[1]					,3					)

																			_UpperCamelCase   :						Optional[Any]												=  tokenizer.prepare_seqaseq_batch(
																			    src_texts=lowerCamelCase__					,max_length=3					,max_target_length=10					,return_tensors='pt'					)
																			self.assertEqual(batch_encoder_only.input_ids.shape[1]					,3					)
																			self.assertEqual(batch_encoder_only.attention_mask.shape[1]					,3					)
																			self.assertNotIn('decoder_input_ids'					,lowerCamelCase__					)





	@unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.'					)
	def       UpperCamelCase_    (					self   :							str					):







							'''simple docstring'''
							pass





	def       UpperCamelCase_    (					self   :							List[str]					):







							'''simple docstring'''
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'					):
																			_UpperCamelCase   :						Optional[Any]												=  [AddedToken('<special>'					,lstrip=lowerCamelCase__					)]

																			_UpperCamelCase   :						Tuple												=  self.rust_tokenizer_class.from_pretrained(
																			    lowerCamelCase__					,additional_special_tokens=lowerCamelCase__					,**lowerCamelCase__					)
																			_UpperCamelCase   :						Union[str, Any]												=  tokenizer_r.encode('Hey this is a <special> token'					)

																			_UpperCamelCase   :						List[str]												=  tokenizer_r.encode('<special>'					,add_special_tokens=lowerCamelCase__					)[0]

																			self.assertTrue(special_token_id in r_output					)

																			if self.test_slow_tokenizer:
																									_UpperCamelCase   :						int												=  self.rust_tokenizer_class.from_pretrained(
																									    lowerCamelCase__					,additional_special_tokens=lowerCamelCase__					,**lowerCamelCase__					,)
																									_UpperCamelCase   :						List[Any]												=  self.tokenizer_class.from_pretrained(
																									    lowerCamelCase__					,additional_special_tokens=lowerCamelCase__					,**lowerCamelCase__					)

																									_UpperCamelCase   :						List[Any]												=  tokenizer_p.encode('Hey this is a <special> token'					)

																									_UpperCamelCase   :						Dict												=  tokenizer_cr.encode('Hey this is a <special> token'					)

																									self.assertEqual(lowerCamelCase__					,lowerCamelCase__					)
																									self.assertEqual(lowerCamelCase__					,lowerCamelCase__					)
																									self.assertTrue(special_token_id in p_output					)
																									self.assertTrue(special_token_id in cr_output					)






@require_torch
@require_sentencepiece
@require_tokenizers
class 				lowercase__      (				unittest.TestCase  ):
	lowercase__    							=     """facebook/nllb-200-distilled-600M"""
	lowercase__    							=     [
	    """ UN Chief Says There Is No Military Solution in Syria""",
	    """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.""",
	]
	lowercase__    							=     [
	    """Şeful ONU declară că nu există o soluţie militară în Siria""",
	    """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"""
	    """ pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"""
	    """ face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
	]
	lowercase__    							=     [
	    25_60_47,
	    1_62_97,
	    13_44_08,
	    81_65,
	    24_80_66,
	    1_47_34,
	    9_50,
	    11_35,
	    10_57_21,
	    35_73,
	    83,
	    2_73_52,
	    1_08,
	    4_94_86,
	    2,
	]





	@classmethod
	def       UpperCamelCase_    (					cls   :							List[str]					):







							'''simple docstring'''
							_UpperCamelCase   :						NllbTokenizer												=  NllbTokenizer.from_pretrained(
							    cls.checkpoint_name					,src_lang='eng_Latn'					,tgt_lang='ron_Latn'					)
							_UpperCamelCase   :						Union[str, Any]												=  1
							return cls





	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab']					,256001					)
							self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn']					,256002					)
							self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn']					,256057					)





	def       UpperCamelCase_    (					self   :							Any					):







							'''simple docstring'''
							_UpperCamelCase   :						Optional[int]												=  self.tokenizer.batch_encode_plus(self.src_text					).input_ids[0]
							self.assertListEqual(self.expected_src_tokens					,lowerCamelCase__					)





	def       UpperCamelCase_    (					self   :							Any					):







							'''simple docstring'''
							self.assertIn(lowerCamelCase__					,self.tokenizer.all_special_ids					)
							# fmt: off
							_UpperCamelCase   :						str												=  [RO_CODE, 4254, 98068, 112923, 39072, 3909, 713, 102767, 26, 17314, 35642, 14683, 33118, 2022, 66987, 2, 256047]
							# fmt: on

							_UpperCamelCase   :						List[Any]												=  self.tokenizer.decode(lowerCamelCase__					,skip_special_tokens=lowerCamelCase__					)
							_UpperCamelCase   :						Optional[Any]												=  self.tokenizer.decode(generated_ids[1:]					,skip_special_tokens=lowerCamelCase__					)
							self.assertEqual(lowerCamelCase__					,lowerCamelCase__					)
							self.assertNotIn(self.tokenizer.eos_token					,lowerCamelCase__					)





	def       UpperCamelCase_    (					self   :							List[Any]					):







							'''simple docstring'''
							_UpperCamelCase   :						List[Any]												=  ['this is gunna be a long sentence ' * 20]
							assert isinstance(src_text[0]					,lowerCamelCase__					)
							_UpperCamelCase   :						List[str]												=  10
							_UpperCamelCase   :						Optional[int]												=  self.tokenizer(lowerCamelCase__					,max_length=lowerCamelCase__					,truncation=lowerCamelCase__					).input_ids[0]
							self.assertEqual(ids[-1]					,2					)
							self.assertEqual(ids[0]					,lowerCamelCase__					)
							self.assertEqual(len(lowerCamelCase__					)					,lowerCamelCase__					)





	def       UpperCamelCase_    (					self   :							str					):







							'''simple docstring'''
							self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']					)					,[256203, 3]					)





	def       UpperCamelCase_    (					self   :							Dict					):







							'''simple docstring'''
							_UpperCamelCase   :						int												=  tempfile.mkdtemp()
							_UpperCamelCase   :						Optional[int]												=  self.tokenizer.fairseq_tokens_to_ids
							self.tokenizer.save_pretrained(lowerCamelCase__					)
							_UpperCamelCase   :						Union[str, Any]												=  NllbTokenizer.from_pretrained(lowerCamelCase__					)
							self.assertDictEqual(new_tok.fairseq_tokens_to_ids					,lowerCamelCase__					)





	@require_torch
	def       UpperCamelCase_    (					self   :							int					):







							'''simple docstring'''
							_UpperCamelCase   :						Dict												=  self.tokenizer(
							    self.src_text					,text_target=self.tgt_text					,padding=lowerCamelCase__					,truncation=lowerCamelCase__					,max_length=len(self.expected_src_tokens					)					,return_tensors='pt'					,)
							_UpperCamelCase   :						Optional[Any]												=  shift_tokens_right(
							    batch['labels']					,self.tokenizer.pad_token_id					,self.tokenizer.lang_code_to_id['ron_Latn']					)

							self.assertIsInstance(lowerCamelCase__					,lowerCamelCase__					)

							self.assertEqual((2, 15)					,batch.input_ids.shape					)
							self.assertEqual((2, 15)					,batch.attention_mask.shape					)
							_UpperCamelCase   :						List[str]												=  batch.input_ids.tolist()[0]
							self.assertListEqual(self.expected_src_tokens					,lowerCamelCase__					)
							self.assertEqual(lowerCamelCase__					,batch.decoder_input_ids[0, 0]					)  # EOS
							# Test that special tokens are reset
							self.assertEqual(self.tokenizer.prefix_tokens					,[EN_CODE]					)
							self.assertEqual(self.tokenizer.suffix_tokens					,[self.tokenizer.eos_token_id]					)





	def       UpperCamelCase_    (					self   :							Optional[Any]					):







							'''simple docstring'''
							_UpperCamelCase   :						Union[str, Any]												=  self.tokenizer(self.src_text					,padding=lowerCamelCase__					,truncation=lowerCamelCase__					,max_length=3					,return_tensors='pt'					)
							_UpperCamelCase   :						Dict												=  self.tokenizer(
							    text_target=self.tgt_text					,padding=lowerCamelCase__					,truncation=lowerCamelCase__					,max_length=10					,return_tensors='pt'					)
							_UpperCamelCase   :						int												=  targets['input_ids']
							_UpperCamelCase   :						Dict												=  shift_tokens_right(
							    lowerCamelCase__					,self.tokenizer.pad_token_id					,decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]					,)

							self.assertEqual(batch.input_ids.shape[1]					,3					)
							self.assertEqual(batch.decoder_input_ids.shape[1]					,10					)





	@require_torch
	def       UpperCamelCase_    (					self   :							Optional[Any]					):







							'''simple docstring'''
							_UpperCamelCase   :						Optional[int]												=  self.tokenizer._build_translation_inputs(
							    'A test'					,return_tensors='pt'					,src_lang='eng_Latn'					,tgt_lang='fra_Latn'					)

							self.assertEqual(
							    nested_simplify(lowerCamelCase__					)					,{
							        # A, test, EOS, en_XX
							        'input_ids': [[256047, 70, 7356, 2]],
							        'attention_mask': [[1, 1, 1, 1]],
							        # ar_AR
							        'forced_bos_token_id': 256057,
							    }					,)





	@require_torch
	def       UpperCamelCase_    (					self   :							List[str]					):







							'''simple docstring'''
							_UpperCamelCase   :						Dict												=  True
							_UpperCamelCase   :						Optional[Any]												=  self.tokenizer(
							    'UN Chief says there is no military solution in Syria'					,src_lang='eng_Latn'					,tgt_lang='fra_Latn'					)
							self.assertEqual(
							    inputs.input_ids					,[16297, 134408, 25653, 6370, 248, 254, 103929, 94995, 108, 49486, 2, 256047]					)

							_UpperCamelCase   :						int												=  False
							_UpperCamelCase   :						Any												=  self.tokenizer(
							    'UN Chief says there is no military solution in Syria'					,src_lang='eng_Latn'					,tgt_lang='fra_Latn'					)
							self.assertEqual(
							    inputs.input_ids					,[256047, 16297, 134408, 25653, 6370, 248, 254, 103929, 94995, 108, 49486, 2]					)







'''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 ViTImageProcessor






class 				lowercase__      (				unittest.TestCase  ):





	def __init__(					self   :							int					,lowerCamelCase__   :							List[str]					,lowerCamelCase__   :							Optional[Any]=13					,lowerCamelCase__   :							List[Any]=3					,lowerCamelCase__   :							Optional[Any]=224					,lowerCamelCase__   :							int=30					,lowerCamelCase__   :							str=400					,lowerCamelCase__   :							str=True					,lowerCamelCase__   :							Any=None					,lowerCamelCase__   :							Tuple=True					,lowerCamelCase__   :							Tuple=[0.5, 0.5, 0.5]					,lowerCamelCase__   :							Optional[int]=[0.5, 0.5, 0.5]					,):







							'''simple docstring'''
							_UpperCamelCase   :						Dict												=  size if size is not None else {'height': 18, 'width': 18}
							_UpperCamelCase   :						List[Any]												=  parent
							_UpperCamelCase   :						Union[str, Any]												=  batch_size
							_UpperCamelCase   :						Dict												=  num_channels
							_UpperCamelCase   :						List[str]												=  image_size
							_UpperCamelCase   :						Optional[Any]												=  min_resolution
							_UpperCamelCase   :						Dict												=  max_resolution
							_UpperCamelCase   :						Tuple												=  do_resize
							_UpperCamelCase   :						Optional[int]												=  size
							_UpperCamelCase   :						Tuple												=  do_normalize
							_UpperCamelCase   :						str												=  image_mean
							_UpperCamelCase   :						int												=  image_std





	def       UpperCamelCase_    (					self   :							List[Any]					):







							'''simple docstring'''
							return {
							    "image_mean": self.image_mean,
							    "image_std": self.image_std,
							    "do_normalize": self.do_normalize,
							    "do_resize": self.do_resize,
							    "size": self.size,
							}






@require_torch
@require_vision
class 				lowercase__      (				lowercase		,   unittest.TestCase  ):
	lowercase__    							=     ViTImageProcessor if is_vision_available() else None





	def       UpperCamelCase_    (					self   :							Optional[Any]					):







							'''simple docstring'''
							_UpperCamelCase   :						Dict												=  EfficientFormerImageProcessorTester(self					)





	@property
	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							return self.image_proc_tester.prepare_image_processor_dict()





	def       UpperCamelCase_    (					self   :							List[str]					):







							'''simple docstring'''
							_UpperCamelCase   :						Optional[int]												=  self.image_processing_class(**self.image_processor_dict					)
							self.assertTrue(hasattr(lowerCamelCase__					,'image_mean'					)					)
							self.assertTrue(hasattr(lowerCamelCase__					,'image_std'					)					)
							self.assertTrue(hasattr(lowerCamelCase__					,'do_normalize'					)					)
							self.assertTrue(hasattr(lowerCamelCase__					,'do_resize'					)					)
							self.assertTrue(hasattr(lowerCamelCase__					,'size'					)					)





	def       UpperCamelCase_    (					self   :							List[str]					):







							'''simple docstring'''
							pass





	def       UpperCamelCase_    (					self   :							int					):







							'''simple docstring'''
							# Initialize image_processor
							_UpperCamelCase   :						str												=  self.image_processing_class(**self.image_processor_dict					)
							# create random PIL images
							_UpperCamelCase   :						Optional[Any]												=  prepare_image_inputs(self.image_proc_tester					,equal_resolution=lowerCamelCase__					)
							for image in image_inputs:
													self.assertIsInstance(lowerCamelCase__					,Image.Image					)

							# Test not batched input
							_UpperCamelCase   :						int												=  image_processor(image_inputs[0]					,return_tensors='pt'					).pixel_values
							self.assertEqual(
							    encoded_images.shape					,(
							        1,
							        self.image_proc_tester.num_channels,
							        self.image_proc_tester.size['height'],
							        self.image_proc_tester.size['width'],
							    )					,)

							# Test batched
							_UpperCamelCase   :						int												=  image_processor(lowerCamelCase__					,return_tensors='pt'					).pixel_values
							self.assertEqual(
							    encoded_images.shape					,(
							        self.image_proc_tester.batch_size,
							        self.image_proc_tester.num_channels,
							        self.image_proc_tester.size['height'],
							        self.image_proc_tester.size['width'],
							    )					,)





	def       UpperCamelCase_    (					self   :							List[str]					):







							'''simple docstring'''
							# Initialize image_processor
							_UpperCamelCase   :						Any												=  self.image_processing_class(**self.image_processor_dict					)
							# create random numpy tensors
							_UpperCamelCase   :						Optional[int]												=  prepare_image_inputs(self.image_proc_tester					,equal_resolution=lowerCamelCase__					,numpify=lowerCamelCase__					)
							for image in image_inputs:
													self.assertIsInstance(lowerCamelCase__					,np.ndarray					)

							# Test not batched input
							_UpperCamelCase   :						Union[str, Any]												=  image_processor(image_inputs[0]					,return_tensors='pt'					).pixel_values
							self.assertEqual(
							    encoded_images.shape					,(
							        1,
							        self.image_proc_tester.num_channels,
							        self.image_proc_tester.size['height'],
							        self.image_proc_tester.size['width'],
							    )					,)

							# Test batched
							_UpperCamelCase   :						Optional[Any]												=  image_processor(lowerCamelCase__					,return_tensors='pt'					).pixel_values
							self.assertEqual(
							    encoded_images.shape					,(
							        self.image_proc_tester.batch_size,
							        self.image_proc_tester.num_channels,
							        self.image_proc_tester.size['height'],
							        self.image_proc_tester.size['width'],
							    )					,)





	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							# Initialize image_processor
							_UpperCamelCase   :						Any												=  self.image_processing_class(**self.image_processor_dict					)
							# create random PyTorch tensors
							_UpperCamelCase   :						Any												=  prepare_image_inputs(self.image_proc_tester					,equal_resolution=lowerCamelCase__					,torchify=lowerCamelCase__					)
							for image in image_inputs:
													self.assertIsInstance(lowerCamelCase__					,torch.Tensor					)

							# Test not batched input
							_UpperCamelCase   :						Dict												=  image_processor(image_inputs[0]					,return_tensors='pt'					).pixel_values
							self.assertEqual(
							    encoded_images.shape					,(
							        1,
							        self.image_proc_tester.num_channels,
							        self.image_proc_tester.size['height'],
							        self.image_proc_tester.size['width'],
							    )					,)

							# Test batched
							_UpperCamelCase   :						Any												=  image_processor(lowerCamelCase__					,return_tensors='pt'					).pixel_values
							self.assertEqual(
							    encoded_images.shape					,(
							        self.image_proc_tester.batch_size,
							        self.image_proc_tester.num_channels,
							        self.image_proc_tester.size['height'],
							        self.image_proc_tester.size['width'],
							    )					,)


