
'''simple docstring'''


import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
			from test_module.custom_tokenization_fast import CustomTokenizerFast


class 						lowercase__	(  unittest.TestCase   ):






			'''simple docstring'''







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  0







			@slow
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )
									self.assertIsNotNone(lowerCamelCase__   )
									self.assertIsInstance(lowerCamelCase__ ,   (BertTokenizer, BertTokenizerFast)   )
									self.assertGreater(len(lowerCamelCase__   ) ,   0   )

						for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )
									self.assertIsNotNone(lowerCamelCase__   )
									self.assertIsInstance(lowerCamelCase__ ,   (GPTaTokenizer, GPTaTokenizerFast)   )
									self.assertGreater(len(lowerCamelCase__   ) ,   0   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )
						self.assertIsInstance(lowerCamelCase__ ,   (BertTokenizer, BertTokenizerFast)   )
						self.assertEqual(tokenizer.vocab_size ,   1_2   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )
						self.assertIsInstance(lowerCamelCase__ ,   (RobertaTokenizer, RobertaTokenizerFast)   )
						self.assertEqual(tokenizer.vocab_size ,   2_0   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoConfig.from_pretrained(lowerCamelCase__   )
						self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )
						# Check that tokenizer_type ≠ model_type
						UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   config=lowerCamelCase__   )
						self.assertIsInstance(lowerCamelCase__ ,   (BertTokenizer, BertTokenizerFast)   )
						self.assertEqual(tokenizer.vocab_size ,   1_2   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						with tempfile.TemporaryDirectory() as tmp_dir:
									shutil.copy('''./tests/fixtures/vocab.txt''' ,   os.path.join(lowerCamelCase__ ,   '''vocab.txt'''   )   )

									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   tokenizer_type='''bert''' ,   use_fast=lowerCamelCase__   )
									self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )

						with tempfile.TemporaryDirectory() as tmp_dir:
									shutil.copy('''./tests/fixtures/vocab.json''' ,   os.path.join(lowerCamelCase__ ,   '''vocab.json'''   )   )
									shutil.copy('''./tests/fixtures/merges.txt''' ,   os.path.join(lowerCamelCase__ ,   '''merges.txt'''   )   )

									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   tokenizer_type='''gpt2''' ,   use_fast=lowerCamelCase__   )
									self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )







			@require_tokenizers
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						with tempfile.TemporaryDirectory() as tmp_dir:
									shutil.copy('''./tests/fixtures/vocab.txt''' ,   os.path.join(lowerCamelCase__ ,   '''vocab.txt'''   )   )

									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   tokenizer_type='''bert'''   )
									self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )

						with tempfile.TemporaryDirectory() as tmp_dir:
									shutil.copy('''./tests/fixtures/vocab.json''' ,   os.path.join(lowerCamelCase__ ,   '''vocab.json'''   )   )
									shutil.copy('''./tests/fixtures/merges.txt''' ,   os.path.join(lowerCamelCase__ ,   '''merges.txt'''   )   )

									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   tokenizer_type='''gpt2'''   )
									self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						with pytest.raises(lowerCamelCase__   ):
									AutoTokenizer.from_pretrained('''./''' ,   tokenizer_type='''xxx'''   )







			@require_tokenizers
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
									UpperCamelCase       =  tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased'''   )
									self.assertIsInstance(lowerCamelCase__ ,   (BertTokenizer, BertTokenizerFast)   )

									if isinstance(lowerCamelCase__ ,   lowerCamelCase__   ):
												self.assertEqual(tokenizer.basic_tokenizer.do_lower_case ,   lowerCamelCase__   )
									else:
												self.assertEqual(tokenizer.do_lower_case ,   lowerCamelCase__   )

									self.assertEqual(tokenizer.model_max_length ,   5_1_2   )







			@require_tokenizers
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
									with self.assertRaisesRegex(
									    lowerCamelCase__ ,   '''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier''' ,   ):
												UpperCamelCase       =  tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  TOKENIZER_MAPPING.values()
						UpperCamelCase       =  []

						for slow_tok, fast_tok in tokenizers:
									if slow_tok is not None:
												tokenizer_names.append(slow_tok.__name__   )

									if fast_tok is not None:
												tokenizer_names.append(fast_tok.__name__   )

						for tokenizer_name in tokenizer_names:
									# must find the right class
									tokenizer_class_from_name(lowerCamelCase__   )







			@require_tokenizers
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased''' ,   use_fast=lowerCamelCase__   ) ,   lowerCamelCase__   )
						self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''   ) ,   lowerCamelCase__   )







			@require_tokenizers
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoTokenizer.from_pretrained('''distilbert-base-uncased''' ,   do_lower_case=lowerCamelCase__   )
						UpperCamelCase       =  '''Hello, world. How are you?'''
						UpperCamelCase       =  tokenizer.tokenize(lowerCamelCase__   )
						self.assertEqual('''[UNK]''' ,   tokens[0]   )

						UpperCamelCase       =  AutoTokenizer.from_pretrained('''microsoft/mpnet-base''' ,   do_lower_case=lowerCamelCase__   )
						UpperCamelCase       =  tokenizer.tokenize(lowerCamelCase__   )
						self.assertEqual('''[UNK]''' ,   tokens[0]   )







			@require_tokenizers
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''   )
						self.assertEqual(type(lowerCamelCase__   ) ,   lowerCamelCase__   )
						self.assertEqual(tokenizer.model_max_length ,   5_1_2   )
						self.assertEqual(tokenizer.vocab_size ,   3_0_0_0_0   )
						self.assertEqual(tokenizer.unk_token ,   '''[UNK]'''   )
						self.assertEqual(tokenizer.padding_side ,   '''right'''   )
						self.assertEqual(tokenizer.truncation_side ,   '''right'''   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )
						self.assertIsInstance(lowerCamelCase__ ,   (BertTokenizer, BertTokenizerFast)   )
						with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(lowerCamelCase__   )
									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )

						self.assertIsInstance(lowerCamelCase__ ,   tokenizer.__class__   )
						self.assertEqual(tokenizera.vocab_size ,   1_2   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoTokenizer.from_pretrained('''ctrl'''   )
						# There is no fast CTRL so this always gives us a slow tokenizer.
						self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  get_tokenizer_config('''bert-base-cased'''   )
						UpperCamelCase       =  config.pop('''_commit_hash''' ,   lowerCamelCase__   )
						# If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
						self.assertEqual(lowerCamelCase__ ,   {'''do_lower_case''': False}   )

						# This model does not have a tokenizer_config so we get back an empty dict.
						UpperCamelCase       =  get_tokenizer_config(lowerCamelCase__   )
						self.assertDictEqual(lowerCamelCase__ ,   {}   )

						# A tokenizer saved with `save_pretrained` always creates a tokenizer config.
						UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )
						with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(lowerCamelCase__   )
									UpperCamelCase       =  get_tokenizer_config(lowerCamelCase__   )

						# Check the class of the tokenizer was properly saved (note that it always saves the slow class).
						self.assertEqual(config['''tokenizer_class'''] ,   '''BertTokenizer'''   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						try:
									AutoConfig.register('''custom''' ,   lowerCamelCase__   )

									AutoTokenizer.register(lowerCamelCase__ ,   slow_tokenizer_class=lowerCamelCase__   )
									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(lowerCamelCase__   ):
												AutoTokenizer.register(lowerCamelCase__ ,   slow_tokenizer_class=lowerCamelCase__   )

									UpperCamelCase       =  CustomTokenizer.from_pretrained(lowerCamelCase__   )
									with tempfile.TemporaryDirectory() as tmp_dir:
												tokenizer.save_pretrained(lowerCamelCase__   )

												UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )
												self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )

						finally:
									if "custom" in CONFIG_MAPPING._extra_content:
												del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in TOKENIZER_MAPPING._extra_content:
												del TOKENIZER_MAPPING._extra_content[CustomConfig]







			@require_tokenizers
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						try:
									AutoConfig.register('''custom''' ,   lowerCamelCase__   )

									# Can register in two steps
									AutoTokenizer.register(lowerCamelCase__ ,   slow_tokenizer_class=lowerCamelCase__   )
									self.assertEqual(TOKENIZER_MAPPING[CustomConfig] ,   (CustomTokenizer, None)   )
									AutoTokenizer.register(lowerCamelCase__ ,   fast_tokenizer_class=lowerCamelCase__   )
									self.assertEqual(TOKENIZER_MAPPING[CustomConfig] ,   (CustomTokenizer, CustomTokenizerFast)   )

									del TOKENIZER_MAPPING._extra_content[CustomConfig]
									# Can register in one step
									AutoTokenizer.register(
									    lowerCamelCase__ ,   slow_tokenizer_class=lowerCamelCase__ ,   fast_tokenizer_class=lowerCamelCase__   )
									self.assertEqual(TOKENIZER_MAPPING[CustomConfig] ,   (CustomTokenizer, CustomTokenizerFast)   )

									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(lowerCamelCase__   ):
												AutoTokenizer.register(lowerCamelCase__ ,   fast_tokenizer_class=lowerCamelCase__   )

									# We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
									# and that model does not have a tokenizer.json
									with tempfile.TemporaryDirectory() as tmp_dir:
												UpperCamelCase       =  BertTokenizerFast.from_pretrained(lowerCamelCase__   )
												bert_tokenizer.save_pretrained(lowerCamelCase__   )
												UpperCamelCase       =  CustomTokenizerFast.from_pretrained(lowerCamelCase__   )

									with tempfile.TemporaryDirectory() as tmp_dir:
												tokenizer.save_pretrained(lowerCamelCase__   )

												UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__   )
												self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )

												UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   use_fast=lowerCamelCase__   )
												self.assertIsInstance(lowerCamelCase__ ,   lowerCamelCase__   )

						finally:
									if "custom" in CONFIG_MAPPING._extra_content:
												del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in TOKENIZER_MAPPING._extra_content:
												del TOKENIZER_MAPPING._extra_content[CustomConfig]







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						with self.assertRaises(lowerCamelCase__   ):
									UpperCamelCase       =  AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''   )
						# If remote code is disabled, we can't load this config.
						with self.assertRaises(lowerCamelCase__   ):
									UpperCamelCase       =  AutoTokenizer.from_pretrained(
									    '''hf-internal-testing/test_dynamic_tokenizer''' ,   trust_remote_code=lowerCamelCase__   )

						UpperCamelCase       =  AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''' ,   trust_remote_code=lowerCamelCase__   )
						self.assertTrue(tokenizer.special_attribute_present   )
						# Test tokenizer can be reloaded.
						with tempfile.TemporaryDirectory() as tmp_dir:
									tokenizer.save_pretrained(lowerCamelCase__   )
									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   trust_remote_code=lowerCamelCase__   )
						self.assertTrue(reloaded_tokenizer.special_attribute_present   )

						if is_tokenizers_available():
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizerFast'''   )
									self.assertEqual(reloaded_tokenizer.__class__.__name__ ,   '''NewTokenizerFast'''   )

									# Test we can also load the slow version
									UpperCamelCase       =  AutoTokenizer.from_pretrained(
									    '''hf-internal-testing/test_dynamic_tokenizer''' ,   trust_remote_code=lowerCamelCase__ ,   use_fast=lowerCamelCase__   )
									self.assertTrue(tokenizer.special_attribute_present   )
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )
									# Test tokenizer can be reloaded.
									with tempfile.TemporaryDirectory() as tmp_dir:
												tokenizer.save_pretrained(lowerCamelCase__   )
												UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   trust_remote_code=lowerCamelCase__ ,   use_fast=lowerCamelCase__   )
									self.assertEqual(reloaded_tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )
									self.assertTrue(reloaded_tokenizer.special_attribute_present   )
						else:
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )
									self.assertEqual(reloaded_tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )







			@require_tokenizers
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						class 						lowercase__	(  snake_case_   ):






									'''simple docstring'''







									_snake_case		   =							False




						class 						lowercase__	(  snake_case_   ):






									'''simple docstring'''







									_snake_case		   =							NewTokenizer
									_snake_case		   =							False

						try:
									AutoConfig.register('''custom''' ,   lowerCamelCase__   )
									AutoTokenizer.register(lowerCamelCase__ ,   slow_tokenizer_class=lowerCamelCase__   )
									AutoTokenizer.register(lowerCamelCase__ ,   fast_tokenizer_class=lowerCamelCase__   )
									# If remote code is not set, the default is to use local
									UpperCamelCase       =  AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''   )
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizerFast'''   )
									self.assertFalse(tokenizer.special_attribute_present   )
									UpperCamelCase       =  AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''' ,   use_fast=lowerCamelCase__   )
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )
									self.assertFalse(tokenizer.special_attribute_present   )

									# If remote code is disabled, we load the local one.
									UpperCamelCase       =  AutoTokenizer.from_pretrained(
									    '''hf-internal-testing/test_dynamic_tokenizer''' ,   trust_remote_code=lowerCamelCase__   )
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizerFast'''   )
									self.assertFalse(tokenizer.special_attribute_present   )
									UpperCamelCase       =  AutoTokenizer.from_pretrained(
									    '''hf-internal-testing/test_dynamic_tokenizer''' ,   trust_remote_code=lowerCamelCase__ ,   use_fast=lowerCamelCase__   )
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )
									self.assertFalse(tokenizer.special_attribute_present   )

									# If remote is enabled, we load from the Hub
									UpperCamelCase       =  AutoTokenizer.from_pretrained(
									    '''hf-internal-testing/test_dynamic_tokenizer''' ,   trust_remote_code=lowerCamelCase__   )
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizerFast'''   )
									self.assertTrue(tokenizer.special_attribute_present   )
									UpperCamelCase       =  AutoTokenizer.from_pretrained(
									    '''hf-internal-testing/test_dynamic_tokenizer''' ,   trust_remote_code=lowerCamelCase__ ,   use_fast=lowerCamelCase__   )
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )
									self.assertTrue(tokenizer.special_attribute_present   )

						finally:
									if "custom" in CONFIG_MAPPING._extra_content:
												del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in TOKENIZER_MAPPING._extra_content:
												del TOKENIZER_MAPPING._extra_content[CustomConfig]







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoTokenizer.from_pretrained(
						    '''hf-internal-testing/test_dynamic_tokenizer_legacy''' ,   trust_remote_code=lowerCamelCase__   )
						self.assertTrue(tokenizer.special_attribute_present   )
						if is_tokenizers_available():
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizerFast'''   )

									# Test we can also load the slow version
									UpperCamelCase       =  AutoTokenizer.from_pretrained(
									    '''hf-internal-testing/test_dynamic_tokenizer_legacy''' ,   trust_remote_code=lowerCamelCase__ ,   use_fast=lowerCamelCase__   )
									self.assertTrue(tokenizer.special_attribute_present   )
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )
						else:
									self.assertEqual(tokenizer.__class__.__name__ ,   '''NewTokenizer'''   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						with self.assertRaisesRegex(
						    lowerCamelCase__ ,   '''bert-base is not a local folder and is not a valid model identifier'''   ):
									UpperCamelCase       =  AutoTokenizer.from_pretrained('''bert-base'''   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						with self.assertRaisesRegex(
						    lowerCamelCase__ ,   R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''   ):
									UpperCamelCase       =  AutoTokenizer.from_pretrained(lowerCamelCase__ ,   revision='''aaaaaa'''   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''   )
						with RequestCounter() as counter:
									UpperCamelCase       =  AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''   )
									self.assertEqual(counter.get_request_count ,   0   )
									self.assertEqual(counter.head_request_count ,   1   )
									self.assertEqual(counter.other_request_count ,   0   )







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


class 						lowercase__	(  unittest.TestCase   ):






   '''simple docstring'''







   def __init__(			self ,   lowerCamelCase__ ,   lowerCamelCase__=7 ,   lowerCamelCase__=3 ,   lowerCamelCase__=1_8 ,   lowerCamelCase__=3_0 ,   lowerCamelCase__=4_0_0 ,   lowerCamelCase__=True ,   lowerCamelCase__=None ,   lowerCamelCase__=True ,   lowerCamelCase__=None ,   lowerCamelCase__=True ,   lowerCamelCase__=[0.5, 0.5, 0.5] ,   lowerCamelCase__=[0.5, 0.5, 0.5] ,   ):

      '''simple docstring'''







      UpperCamelCase       =  size if size is not None else {'''shortest_edge''': 1_8}
      UpperCamelCase       =  crop_size if crop_size is not None else {'''height''': 1_8, '''width''': 1_8}
      UpperCamelCase       =  parent
      UpperCamelCase       =  batch_size
      UpperCamelCase       =  num_channels
      UpperCamelCase       =  image_size
      UpperCamelCase       =  min_resolution
      UpperCamelCase       =  max_resolution
      UpperCamelCase       =  do_resize
      UpperCamelCase       =  size
      UpperCamelCase       =  do_center_crop
      UpperCamelCase       =  crop_size
      UpperCamelCase       =  do_normalize
      UpperCamelCase       =  image_mean
      UpperCamelCase       =  image_std







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      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 						lowercase__	(  snake_case_,					unittest.TestCase   ):






   '''simple docstring'''







   _snake_case		   =							LevitImageProcessor if is_vision_available() else None







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  LevitImageProcessingTester(self   )







   @property
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      return self.image_processor_tester.prepare_image_processor_dict()







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  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       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class.from_dict(self.image_processor_dict   )
      self.assertEqual(image_processor.size ,   {'''shortest_edge''': 1_8}   )
      self.assertEqual(image_processor.crop_size ,   {'''height''': 1_8, '''width''': 1_8}   )

      UpperCamelCase       =  self.image_processing_class.from_dict(self.image_processor_dict ,   size=4_2 ,   crop_size=8_4   )
      self.assertEqual(image_processor.size ,   {'''shortest_edge''': 4_2}   )
      self.assertEqual(image_processor.crop_size ,   {'''height''': 8_4, '''width''': 8_4}   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      pass







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class(**self.image_processor_dict   )
      # create random PIL images
      UpperCamelCase       =  prepare_image_inputs(self.image_processor_tester ,   equal_resolution=lowerCamelCase__   )
      for image in image_inputs:
         self.assertIsInstance(lowerCamelCase__ ,   Image.Image   )

      # Test not batched input
      UpperCamelCase       =  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
      UpperCamelCase       =  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       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class(**self.image_processor_dict   )
      # create random numpy tensors
      UpperCamelCase       =  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
      UpperCamelCase       =  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
      UpperCamelCase       =  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       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.image_processing_class(**self.image_processor_dict   )
      # create random PyTorch tensors
      UpperCamelCase       =  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
      UpperCamelCase       =  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
      UpperCamelCase       =  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'''],
          ) ,   )





