




import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, ByTaTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
   lowerCamelCase__			:       Tuple         =							'pt'
elif is_tf_available():
   lowerCamelCase__			:       Tuple         =							'tf'
else:
   lowerCamelCase__			:       List[Any]         =							'jax'





class 	lowerCamelCase_							(				_SCREAMING_SNAKE_CASE	,       unittest.TestCase ):


 '''simple docstring'''







 lowercase_       =   ByTaTokenizer
 lowercase_       =   False



 def 				lowerCAmelCase_  (							self  :		int						):
       super().setUp()
       SCREAMING_SNAKE_CASE_     						=      ByTaTokenizer()
       tokenizer.save_pretrained(self.tmpdirname						)



 @cached_property
 def 				lowerCAmelCase_  (							self  :		Optional[Any]						):
       return ByTaTokenizer.from_pretrained('google/byt5-small'						)



 def 				lowerCAmelCase_  (							self  :		Any    ,    **_lowerCAmelCase  :		str						):
       return self.tokenizer_class.from_pretrained(self.tmpdirname    ,    **_lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		Dict    ,    _lowerCAmelCase  :		Union[str, Any]    ,    _lowerCAmelCase  :		List[str]=False    ,    _lowerCAmelCase  :		Tuple=20    ,    _lowerCAmelCase  :		Optional[int]=5						):
       # XXX The default common tokenizer tests assume that every ID is decodable on its own.
       # This assumption is invalid for ByT5 because single bytes might not be
       # valid utf-8 (byte 128 for instance).
       # Here we're overriding the smallest possible method to provide
       # a clean sequence without making the same assumption.

       SCREAMING_SNAKE_CASE_     						=      []
       for i in range(len(_lowerCAmelCase						)						):
             try:
                   SCREAMING_SNAKE_CASE_     						=      tokenizer.decode([i]    ,    clean_up_tokenization_spaces=_lowerCAmelCase						)
             except UnicodeDecodeError:
                   pass
             toks.append((i, tok)						)

       SCREAMING_SNAKE_CASE_     						=      list(filter(lambda _lowerCAmelCase						: re.match(R'^[ a-zA-Z]+$'    ,    t[1]						)    ,    _lowerCAmelCase						)						)
       SCREAMING_SNAKE_CASE_     						=      list(filter(lambda _lowerCAmelCase						: [t[0]] == tokenizer.encode(t[1]    ,    add_special_tokens=_lowerCAmelCase						)    ,    _lowerCAmelCase						)						)
       if max_length is not None and len(_lowerCAmelCase						) > max_length:
             SCREAMING_SNAKE_CASE_     						=      toks[:max_length]
       if min_length is not None and len(_lowerCAmelCase						) < min_length and len(_lowerCAmelCase						) > 0:
             while len(_lowerCAmelCase						) < min_length:
                   SCREAMING_SNAKE_CASE_     						=      toks + toks
        # toks_str = [t[1] for t in toks]
       SCREAMING_SNAKE_CASE_     						=      [t[0] for t in toks]

       # Ensure consistency
       SCREAMING_SNAKE_CASE_     						=      tokenizer.decode(_lowerCAmelCase    ,    clean_up_tokenization_spaces=_lowerCAmelCase						)
       if " " not in output_txt and len(_lowerCAmelCase						) > 1:
             SCREAMING_SNAKE_CASE_     						=      (
                 tokenizer.decode([toks_ids[0]]    ,    clean_up_tokenization_spaces=_lowerCAmelCase						)
                 + ' '
                 + tokenizer.decode(toks_ids[1:]    ,    clean_up_tokenization_spaces=_lowerCAmelCase						)
             )
       if with_prefix_space:
             SCREAMING_SNAKE_CASE_     						=      ' ' + output_txt
       SCREAMING_SNAKE_CASE_     						=      tokenizer.encode(_lowerCAmelCase    ,    add_special_tokens=_lowerCAmelCase						)
       return output_txt, output_ids



 def 				lowerCAmelCase_  (							self  :		Dict						):
       SCREAMING_SNAKE_CASE_     						=      self.ta_base_tokenizer
       SCREAMING_SNAKE_CASE_     						=      tokenizer(['hi</s>', 'I went to the gym</s>', '</s>']						)
       SCREAMING_SNAKE_CASE_     						=      tokenizer(['hi', 'I went to the gym', '']						)
       self.assertListEqual(batch_with_eos_added['input_ids']    ,    batch_without_eos_added['input_ids']						)



 def 				lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_     						=      self.ta_base_tokenizer
       SCREAMING_SNAKE_CASE_     						=      'Unicode €.'
       SCREAMING_SNAKE_CASE_     						=      tokenizer(_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      [88, 113, 108, 102, 114, 103, 104, 35, 229, 133, 175, 49, 1]
       self.assertEqual(encoded['input_ids']    ,    _lowerCAmelCase						)

       # decoding
       SCREAMING_SNAKE_CASE_     						=      tokenizer.decode(_lowerCAmelCase						)
       self.assertEqual(_lowerCAmelCase    ,    'Unicode €.</s>'						)

       SCREAMING_SNAKE_CASE_     						=      tokenizer('e è é ê ë'						)
       SCREAMING_SNAKE_CASE_     						=      [104, 35, 198, 171, 35, 198, 172, 35, 198, 173, 35, 198, 174, 1]
       self.assertEqual(encoded['input_ids']    ,    _lowerCAmelCase						)
       # decoding
       SCREAMING_SNAKE_CASE_     						=      tokenizer.decode(_lowerCAmelCase						)
       self.assertEqual(_lowerCAmelCase    ,    'e è é ê ë</s>'						)

       # encode/decode, but with `encode` instead of `__call__`
       self.assertEqual(tokenizer.decode(tokenizer.encode('e è é ê ë'						)						)    ,    'e è é ê ë</s>'						)



 def 				lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_     						=      self.ta_base_tokenizer
       SCREAMING_SNAKE_CASE_     						=      ['A long paragraph for summarization.', 'Another paragraph for summarization.']
       # fmt: off
       SCREAMING_SNAKE_CASE_     						=      [68, 35, 111, 114, 113, 106, 35, 115, 100, 117, 100, 106, 117, 100, 115, 107, 35, 105, 114, 117, 35, 118, 120, 112, 112, 100, 117, 108, 125, 100, 119, 108, 114, 113, 49, 1, 0]
       # fmt: on
       SCREAMING_SNAKE_CASE_     						=      tokenizer(_lowerCAmelCase    ,    padding=_lowerCAmelCase    ,    return_tensors=_lowerCAmelCase						)
       self.assertIsInstance(_lowerCAmelCase    ,    _lowerCAmelCase						)

       if FRAMEWORK != "jax":
             SCREAMING_SNAKE_CASE_     						=      list(batch.input_ids.numpy()[0]						)
       else:
             SCREAMING_SNAKE_CASE_     						=      list(batch.input_ids.tolist()[0]						)

       self.assertListEqual(_lowerCAmelCase    ,    _lowerCAmelCase						)

       self.assertEqual((2, 37)    ,    batch.input_ids.shape						)
       self.assertEqual((2, 37)    ,    batch.attention_mask.shape						)



 def 				lowerCAmelCase_  (							self  :		Tuple						):
       SCREAMING_SNAKE_CASE_     						=      self.ta_base_tokenizer
       SCREAMING_SNAKE_CASE_     						=      ['A long paragraph for summarization.', 'Another paragraph for summarization.']
       SCREAMING_SNAKE_CASE_     						=      tokenizer(_lowerCAmelCase    ,    padding=_lowerCAmelCase    ,    return_tensors=_lowerCAmelCase						)
       # check if input_ids are returned and no decoder_input_ids
       self.assertIn('input_ids'    ,    _lowerCAmelCase						)
       self.assertIn('attention_mask'    ,    _lowerCAmelCase						)
       self.assertNotIn('decoder_input_ids'    ,    _lowerCAmelCase						)
       self.assertNotIn('decoder_attention_mask'    ,    _lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		Dict						):
       SCREAMING_SNAKE_CASE_     						=      self.ta_base_tokenizer
       SCREAMING_SNAKE_CASE_     						=      [
           'Summary of the text.',
           'Another summary.',
       ]
       SCREAMING_SNAKE_CASE_     						=      tokenizer(
           text_target=_lowerCAmelCase    ,    max_length=32    ,    padding='max_length'    ,    truncation=_lowerCAmelCase    ,    return_tensors=_lowerCAmelCase						)
       self.assertEqual(32    ,    targets['input_ids'].shape[1]						)



 def 				lowerCAmelCase_  (							self  :		Any						):
       SCREAMING_SNAKE_CASE_     						=      self.ta_base_tokenizer
       SCREAMING_SNAKE_CASE_     						=      ['A long paragraph for summarization. </s>']
       SCREAMING_SNAKE_CASE_     						=      ['Summary of the text. </s>']
       # fmt: off
       SCREAMING_SNAKE_CASE_     						=      [68, 35, 111, 114, 113, 106, 35, 115, 100, 117, 100, 106, 117, 100, 115, 107, 35, 105, 114, 117, 35, 118, 120, 112, 112, 100, 117, 108, 125, 100, 119, 108, 114, 113, 49, 35, 1]
       SCREAMING_SNAKE_CASE_     						=      [86, 120, 112, 112, 100, 117, 124, 35, 114, 105, 35, 119, 107, 104, 35, 119, 104, 123, 119, 49, 35, 1]
       # fmt: on

       SCREAMING_SNAKE_CASE_     						=      tokenizer(_lowerCAmelCase    ,    text_target=_lowerCAmelCase						)

       self.assertEqual(_lowerCAmelCase    ,    batch['input_ids'][0]						)
       self.assertEqual(_lowerCAmelCase    ,    batch['labels'][0]						)



 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       # safety check on max_len default value so we are sure the test works
       SCREAMING_SNAKE_CASE_     						=      self.get_tokenizers()
       for tokenizer in tokenizers:
             with self.subTest(F"{tokenizer.__class__.__name__}"						):
                   self.assertNotEqual(tokenizer.model_max_length    ,    42						)

        # Now let's start the test
       SCREAMING_SNAKE_CASE_     						=      self.get_tokenizers()
       for tokenizer in tokenizers:
             with self.subTest(F"{tokenizer.__class__.__name__}"						):
                   # Isolate this from the other tests because we save additional tokens/etc
                   SCREAMING_SNAKE_CASE_     						=      tempfile.mkdtemp()

                   SCREAMING_SNAKE_CASE_     						=      ' He is very happy, UNwant\u00E9d,running'
                   SCREAMING_SNAKE_CASE_     						=      tokenizer.encode(_lowerCAmelCase    ,    add_special_tokens=_lowerCAmelCase						)
                   tokenizer.save_pretrained(_lowerCAmelCase						)

                   SCREAMING_SNAKE_CASE_     						=      tokenizer.__class__.from_pretrained(_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      after_tokenizer.encode(_lowerCAmelCase    ,    add_special_tokens=_lowerCAmelCase						)
                   self.assertListEqual(_lowerCAmelCase    ,    _lowerCAmelCase						)

                   shutil.rmtree(_lowerCAmelCase						)

       SCREAMING_SNAKE_CASE_     						=      self.get_tokenizers(model_max_length=42						)
       for tokenizer in tokenizers:
             with self.subTest(F"{tokenizer.__class__.__name__}"						):
                   # Isolate this from the other tests because we save additional tokens/etc
                   SCREAMING_SNAKE_CASE_     						=      tempfile.mkdtemp()

                   SCREAMING_SNAKE_CASE_     						=      ' He is very happy, UNwant\u00E9d,running'
                   tokenizer.add_tokens(['bim', 'bambam']						)
                   SCREAMING_SNAKE_CASE_     						=      tokenizer.additional_special_tokens
                   additional_special_tokens.append('new_additional_special_token'						)
                   tokenizer.add_special_tokens({'additional_special_tokens': additional_special_tokens}						)
                   SCREAMING_SNAKE_CASE_     						=      tokenizer.encode(_lowerCAmelCase    ,    add_special_tokens=_lowerCAmelCase						)
                   tokenizer.save_pretrained(_lowerCAmelCase						)

                   SCREAMING_SNAKE_CASE_     						=      tokenizer.__class__.from_pretrained(_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_     						=      after_tokenizer.encode(_lowerCAmelCase    ,    add_special_tokens=_lowerCAmelCase						)
                   self.assertListEqual(_lowerCAmelCase    ,    _lowerCAmelCase						)
                   self.assertIn('new_additional_special_token'    ,    after_tokenizer.additional_special_tokens						)
                   self.assertEqual(after_tokenizer.model_max_length    ,    42						)

                   SCREAMING_SNAKE_CASE_     						=      tokenizer.__class__.from_pretrained(_lowerCAmelCase    ,    model_max_length=43						)
                   self.assertEqual(tokenizer.model_max_length    ,    43						)

                   shutil.rmtree(_lowerCAmelCase						)



 def 				lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_     						=      []
       if self.test_slow_tokenizer:
             tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())						)

       if self.test_rust_tokenizer:
             tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())						)

       for tokenizer_class, tokenizer_utils in tokenizer_list:
             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer_utils.save_pretrained(_lowerCAmelCase						)

                   with open(os.path.join(_lowerCAmelCase    ,    'special_tokens_map.json'						)    ,    encoding='utf-8'						) as json_file:
                         SCREAMING_SNAKE_CASE_     						=      json.load(_lowerCAmelCase						)

                   with open(os.path.join(_lowerCAmelCase    ,    'tokenizer_config.json'						)    ,    encoding='utf-8'						) as json_file:
                         SCREAMING_SNAKE_CASE_     						=      json.load(_lowerCAmelCase						)

                   SCREAMING_SNAKE_CASE_     						=      [F"<extra_id_{i}>" for i in range(125						)]

                   SCREAMING_SNAKE_CASE_     						=      added_tokens_extra_ids + [
                       'an_additional_special_token'
                   ]
                   SCREAMING_SNAKE_CASE_     						=      added_tokens_extra_ids + [
                       'an_additional_special_token'
                   ]

                   with open(os.path.join(_lowerCAmelCase    ,    'special_tokens_map.json'						)    ,    'w'    ,    encoding='utf-8'						) as outfile:
                         json.dump(_lowerCAmelCase    ,    _lowerCAmelCase						)
                   with open(os.path.join(_lowerCAmelCase    ,    'tokenizer_config.json'						)    ,    'w'    ,    encoding='utf-8'						) as outfile:
                         json.dump(_lowerCAmelCase    ,    _lowerCAmelCase						)

                   # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
                   # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
                   # "special_tokens_map.json" files
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_class.from_pretrained(
                       _lowerCAmelCase    ,    )
                   self.assertIn(
                       'an_additional_special_token'    ,    tokenizer_without_change_in_init.additional_special_tokens						)
                   # self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
                   self.assertEqual(
                       ['an_additional_special_token']    ,    tokenizer_without_change_in_init.convert_ids_to_tokens(
                           tokenizer_without_change_in_init.convert_tokens_to_ids(['an_additional_special_token']						)						)    ,    )

                   # Now we test that we can change the value of additional_special_tokens in the from_pretrained
                   SCREAMING_SNAKE_CASE_     						=      added_tokens_extra_ids + [AddedToken('a_new_additional_special_token'    ,    lstrip=_lowerCAmelCase						)]
                   SCREAMING_SNAKE_CASE_     						=      tokenizer_class.from_pretrained(
                       _lowerCAmelCase    ,    additional_special_tokens=_lowerCAmelCase    ,    )

                   self.assertIn('a_new_additional_special_token'    ,    tokenizer.additional_special_tokens						)
                   self.assertEqual(
                       ['a_new_additional_special_token']    ,    tokenizer.convert_ids_to_tokens(
                           tokenizer.convert_tokens_to_ids(['a_new_additional_special_token']						)						)    ,    )



 def 				lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_     						=      []
       if self.test_slow_tokenizer:
             tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())						)

       if self.test_rust_tokenizer:
             tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())						)

       for tokenizer_class, tokenizer_utils in tokenizer_list:
             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer_utils.save_pretrained(_lowerCAmelCase						)

                   SCREAMING_SNAKE_CASE_     						=      tokenizer_class.from_pretrained(_lowerCAmelCase						)

                   self.assertTrue(tokenizer.decode([255]						) == ''						)



 def 				lowerCAmelCase_  (							self  :		Dict						):
       pass



 def 				lowerCAmelCase_  (							self  :		str						):
       pass



 def 				lowerCAmelCase_  (							self  :		List[str]						):
       pass



 def 				lowerCAmelCase_  (							self  :		Dict						):
       pass



 def 				lowerCAmelCase_  (							self  :		List[str]						):
       # The default common tokenizer tests uses invalid tokens for ByT5 that can only accept one-character strings
       # and special added tokens as tokens
       SCREAMING_SNAKE_CASE_     						=      self.get_tokenizers(fast=_lowerCAmelCase    ,    do_lower_case=_lowerCAmelCase						)
       for tokenizer in tokenizers:
             with self.subTest(F"{tokenizer.__class__.__name__}"						):
                   SCREAMING_SNAKE_CASE_     						=      ['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 'x', 't', '</s>']
                   SCREAMING_SNAKE_CASE_     						=      tokenizer.convert_tokens_to_string(_lowerCAmelCase						)

                   self.assertIsInstance(_lowerCAmelCase    ,    _lowerCAmelCase						)




 def 				lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_     						=      self.get_tokenizers()
       for tokenizer in tokenizers:
             with self.subTest(F"{tokenizer.__class__.__name__}"						):
                   SCREAMING_SNAKE_CASE_     						=      [
                       'bos_token',
                       'eos_token',
                       'unk_token',
                       'sep_token',
                       'pad_token',
                       'cls_token',
                       'mask_token',
                   ]

                   SCREAMING_SNAKE_CASE_     						=      0
                   SCREAMING_SNAKE_CASE_     						=      tokenizer.convert_ids_to_tokens(
                       _lowerCAmelCase    ,    skip_special_tokens=_lowerCAmelCase						)

                   for attr in attributes_list:
                         setattr(_lowerCAmelCase    ,    attr + '_id'    ,    _lowerCAmelCase						)
                         self.assertEqual(getattr(_lowerCAmelCase    ,    _lowerCAmelCase						)    ,    _lowerCAmelCase						)
                         self.assertEqual(getattr(_lowerCAmelCase    ,    attr + '_id'						)    ,    _lowerCAmelCase						)

                         setattr(_lowerCAmelCase    ,    attr + '_id'    ,    _lowerCAmelCase						)
                         self.assertEqual(getattr(_lowerCAmelCase    ,    _lowerCAmelCase						)    ,    _lowerCAmelCase						)
                         self.assertEqual(getattr(_lowerCAmelCase    ,    attr + '_id'						)    ,    _lowerCAmelCase						)

                   setattr(_lowerCAmelCase    ,    'additional_special_tokens_ids'    ,    []						)
                   self.assertListEqual(getattr(_lowerCAmelCase    ,    'additional_special_tokens'						)    ,    []						)
                   self.assertListEqual(getattr(_lowerCAmelCase    ,    'additional_special_tokens_ids'						)    ,    []						)

                   setattr(_lowerCAmelCase    ,    'additional_special_tokens_ids'    ,    [token_id_to_test_setters]						)
                   self.assertListEqual(getattr(_lowerCAmelCase    ,    'additional_special_tokens'						)    ,    [token_to_test_setters]						)
                   self.assertListEqual(getattr(_lowerCAmelCase    ,    'additional_special_tokens_ids'						)    ,    [token_id_to_test_setters]						)





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 LevitImageProcessor





class 	lowerCamelCase_							(				unittest.TestCase ):


 '''simple docstring'''







 def __init__(							self  :		str    ,    _lowerCAmelCase  :		Optional[Any]    ,    _lowerCAmelCase  :		Any=7    ,    _lowerCAmelCase  :		Tuple=3    ,    _lowerCAmelCase  :		List[str]=18    ,    _lowerCAmelCase  :		Any=30    ,    _lowerCAmelCase  :		List[Any]=400    ,    _lowerCAmelCase  :		Dict=True    ,    _lowerCAmelCase  :		Tuple=None    ,    _lowerCAmelCase  :		Tuple=True    ,    _lowerCAmelCase  :		Union[str, Any]=None    ,    _lowerCAmelCase  :		Tuple=True    ,    _lowerCAmelCase  :		List[Any]=[0.5, 0.5, 0.5]    ,    _lowerCAmelCase  :		Union[str, Any]=[0.5, 0.5, 0.5]    ,    ):
       SCREAMING_SNAKE_CASE_     						=      size if size is not None else {'shortest_edge': 18}
       SCREAMING_SNAKE_CASE_     						=      crop_size if crop_size is not None else {'height': 18, 'width': 18}
       SCREAMING_SNAKE_CASE_     						=      parent
       SCREAMING_SNAKE_CASE_     						=      batch_size
       SCREAMING_SNAKE_CASE_     						=      num_channels
       SCREAMING_SNAKE_CASE_     						=      image_size
       SCREAMING_SNAKE_CASE_     						=      min_resolution
       SCREAMING_SNAKE_CASE_     						=      max_resolution
       SCREAMING_SNAKE_CASE_     						=      do_resize
       SCREAMING_SNAKE_CASE_     						=      size
       SCREAMING_SNAKE_CASE_     						=      do_center_crop
       SCREAMING_SNAKE_CASE_     						=      crop_size
       SCREAMING_SNAKE_CASE_     						=      do_normalize
       SCREAMING_SNAKE_CASE_     						=      image_mean
       SCREAMING_SNAKE_CASE_     						=      image_std




 def 				lowerCAmelCase_  (							self  :		List[Any]						):
       return {
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_normalize": self.do_normalize,
           "do_resize": self.do_resize,
           "do_center_crop": self.do_center_crop,
           "size": self.size,
           "crop_size": self.crop_size,
       }





@require_torch
@require_vision
class 	lowerCamelCase_							(				_SCREAMING_SNAKE_CASE	,       unittest.TestCase ):


 '''simple docstring'''







 lowercase_       =   LevitImageProcessor if is_vision_available() else None



 def 				lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_     						=      LevitImageProcessingTester(self						)



 @property
 def 				lowerCAmelCase_  (							self  :		Dict						):
       return self.image_processor_tester.prepare_image_processor_dict()



 def 				lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_     						=      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    ,    'do_center_crop'						)						)
       self.assertTrue(hasattr(_lowerCAmelCase    ,    'size'						)						)



 def 				lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_     						=      self.image_processing_class.from_dict(self.image_processor_dict						)
       self.assertEqual(image_processor.size    ,    {'shortest_edge': 18}						)
       self.assertEqual(image_processor.crop_size    ,    {'height': 18, 'width': 18}						)

       SCREAMING_SNAKE_CASE_     						=      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 				lowerCAmelCase_  (							self  :		Dict						):
       pass



 def 				lowerCAmelCase_  (							self  :		int						):
       # Initialize image_processing
       SCREAMING_SNAKE_CASE_     						=      self.image_processing_class(**self.image_processor_dict						)
       # create random PIL images
       SCREAMING_SNAKE_CASE_     						=      prepare_image_inputs(self.image_processor_tester    ,    equal_resolution=_lowerCAmelCase						)
       for image in image_inputs:
             self.assertIsInstance(_lowerCAmelCase    ,    Image.Image						)

       # Test not batched input
       SCREAMING_SNAKE_CASE_     						=      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
       SCREAMING_SNAKE_CASE_     						=      image_processing(_lowerCAmelCase    ,    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 				lowerCAmelCase_  (							self  :		str						):
       # Initialize image_processing
       SCREAMING_SNAKE_CASE_     						=      self.image_processing_class(**self.image_processor_dict						)
       # create random numpy tensors
       SCREAMING_SNAKE_CASE_     						=      prepare_image_inputs(self.image_processor_tester    ,    equal_resolution=_lowerCAmelCase    ,    numpify=_lowerCAmelCase						)
       for image in image_inputs:
             self.assertIsInstance(_lowerCAmelCase    ,    np.ndarray						)

       # Test not batched input
       SCREAMING_SNAKE_CASE_     						=      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
       SCREAMING_SNAKE_CASE_     						=      image_processing(_lowerCAmelCase    ,    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 				lowerCAmelCase_  (							self  :		Tuple						):
       # Initialize image_processing
       SCREAMING_SNAKE_CASE_     						=      self.image_processing_class(**self.image_processor_dict						)
       # create random PyTorch tensors
       SCREAMING_SNAKE_CASE_     						=      prepare_image_inputs(self.image_processor_tester    ,    equal_resolution=_lowerCAmelCase    ,    torchify=_lowerCAmelCase						)
       for image in image_inputs:
             self.assertIsInstance(_lowerCAmelCase    ,    torch.Tensor						)

       # Test not batched input
       SCREAMING_SNAKE_CASE_     						=      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
       SCREAMING_SNAKE_CASE_     						=      image_processing(_lowerCAmelCase    ,    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'],
           )    ,    )