


import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
		    MODEL_MAPPING,
		    LevitForImageClassification,
		    LevitForImageClassificationWithTeacher,
		    LevitModel,
		)
		from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import LevitImageProcessor

class 						__a (							UpperCAmelCase     ):
		def       UpperCAmelCase__							(     self		)					->			List[Any]:




									"""simple docstring"""





									_UpperCAmelCase											=     self.config_class(**self.inputs_dict		)
									self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE     ,       'hidden_sizes'		)		)
									self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE     ,       'num_attention_heads'		)		)



class 						__a :
		def __init__(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE=13     ,       _SCREAMING_SNAKE_CASE=64     ,       _SCREAMING_SNAKE_CASE=3     ,       _SCREAMING_SNAKE_CASE=3     ,       _SCREAMING_SNAKE_CASE=2     ,       _SCREAMING_SNAKE_CASE=1     ,       _SCREAMING_SNAKE_CASE=16     ,       _SCREAMING_SNAKE_CASE=[128, 256, 384]     ,       _SCREAMING_SNAKE_CASE=[4, 6, 8]     ,       _SCREAMING_SNAKE_CASE=[2, 3, 4]     ,       _SCREAMING_SNAKE_CASE=[16, 16, 16]     ,       _SCREAMING_SNAKE_CASE=0     ,       _SCREAMING_SNAKE_CASE=[2, 2, 2]     ,       _SCREAMING_SNAKE_CASE=[2, 2, 2]     ,       _SCREAMING_SNAKE_CASE=0.02     ,       _SCREAMING_SNAKE_CASE=True     ,       _SCREAMING_SNAKE_CASE=True     ,       _SCREAMING_SNAKE_CASE=2     ,       )					->			List[Any]:




									"""simple docstring"""





									_UpperCAmelCase											=     parent
									_UpperCAmelCase											=     batch_size
									_UpperCAmelCase											=     image_size
									_UpperCAmelCase											=     num_channels
									_UpperCAmelCase											=     kernel_size
									_UpperCAmelCase											=     stride
									_UpperCAmelCase											=     padding
									_UpperCAmelCase											=     hidden_sizes
									_UpperCAmelCase											=     num_attention_heads
									_UpperCAmelCase											=     depths
									_UpperCAmelCase											=     key_dim
									_UpperCAmelCase											=     drop_path_rate
									_UpperCAmelCase											=     patch_size
									_UpperCAmelCase											=     attention_ratio
									_UpperCAmelCase											=     mlp_ratio
									_UpperCAmelCase											=     initializer_range
									_UpperCAmelCase											=     [
									    ['Subsample', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
									    ['Subsample', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
									]
									_UpperCAmelCase											=     is_training
									_UpperCAmelCase											=     use_labels
									_UpperCAmelCase											=     num_labels
									_UpperCAmelCase											=     initializer_range
		def       UpperCAmelCase__							(     self		)					->			Dict:




									"""simple docstring"""





									_UpperCAmelCase											=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

									_UpperCAmelCase											=     None
									if self.use_labels:
																_UpperCAmelCase											=     ids_tensor([self.batch_size]     ,       self.num_labels		)

									_UpperCAmelCase											=     self.get_config()
									return config, pixel_values, labels
		def       UpperCAmelCase__							(     self		)					->			List[str]:




									"""simple docstring"""





									return LevitConfig(
									    image_size=self.image_size     ,       num_channels=self.num_channels     ,       kernel_size=self.kernel_size     ,       stride=self.stride     ,       padding=self.padding     ,       patch_size=self.patch_size     ,       hidden_sizes=self.hidden_sizes     ,       num_attention_heads=self.num_attention_heads     ,       depths=self.depths     ,       key_dim=self.key_dim     ,       drop_path_rate=self.drop_path_rate     ,       mlp_ratio=self.mlp_ratio     ,       attention_ratio=self.attention_ratio     ,       initializer_range=self.initializer_range     ,       down_ops=self.down_ops     ,       )
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			List[str]:




									"""simple docstring"""





									_UpperCAmelCase											=     LevitModel(config=_SCREAMING_SNAKE_CASE		)
									model.to(_SCREAMING_SNAKE_CASE		)
									model.eval()
									_UpperCAmelCase											=     model(_SCREAMING_SNAKE_CASE		)
									_UpperCAmelCase											=     (self.image_size, self.image_size)
									_UpperCAmelCase						,			_UpperCAmelCase											=     image_size[0], image_size[1]
									for _ in range(4		):
																_UpperCAmelCase											=     floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1		)
																_UpperCAmelCase											=     floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1		)
									self.parent.assertEqual(
									    result.last_hidden_state.shape     ,       (self.batch_size, ceil(height / 4		) * ceil(width / 4		), self.hidden_sizes[-1])     ,       )
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase											=     self.num_labels
									_UpperCAmelCase											=     LevitForImageClassification(_SCREAMING_SNAKE_CASE		)
									model.to(_SCREAMING_SNAKE_CASE		)
									model.eval()
									_UpperCAmelCase											=     model(_SCREAMING_SNAKE_CASE     ,       labels=_SCREAMING_SNAKE_CASE		)
									self.parent.assertEqual(result.logits.shape     ,       (self.batch_size, self.num_labels)		)






		def       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase											=     self.prepare_config_and_inputs()
									_UpperCAmelCase						,			_UpperCAmelCase						,			_UpperCAmelCase											=     config_and_inputs
									_UpperCAmelCase											=     {'pixel_values': pixel_values}
									return config, inputs_dict



@require_torch
class 						__a (							UpperCAmelCase       , UpperCAmelCase       , unittest.TestCase     ):
		_a      :    str           =      (
		    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
		    if is_torch_available()
		    else ()
		)
		_a      :    Optional[int]           =      (
		    {
		        'feature-extraction': LevitModel,
		        'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
		    }
		    if is_torch_available()
		    else {}
		)

		_a      :    Union[str, Any]           =      False
		_a      :    str           =      False
		_a      :    Tuple           =      False
		_a      :    str           =      False
		_a      :    Optional[int]           =      False
		def       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase											=     LevitModelTester(self		)
									_UpperCAmelCase											=     ConfigTester(self     ,       config_class=_SCREAMING_SNAKE_CASE     ,       has_text_modality=_SCREAMING_SNAKE_CASE     ,       hidden_size=37		)
		def       UpperCAmelCase__							(     self		)					->			Dict:




									"""simple docstring"""





									self.create_and_test_config_common_properties()
									self.config_tester.create_and_test_config_to_json_string()
									self.config_tester.create_and_test_config_to_json_file()
									self.config_tester.create_and_test_config_from_and_save_pretrained()
									self.config_tester.create_and_test_config_with_num_labels()
									self.config_tester.check_config_can_be_init_without_params()
									self.config_tester.check_config_arguments_init()
		def       UpperCAmelCase__							(     self		)					->			Optional[Any]:




									"""simple docstring"""





									return
		@unittest.skip(reason='Levit does not use inputs_embeds'		)
		def       UpperCAmelCase__							(     self		)					->			Any:




									"""simple docstring"""





									pass
		@unittest.skip(reason='Levit does not support input and output embeddings'		)
		def       UpperCAmelCase__							(     self		)					->			List[Any]:




									"""simple docstring"""





									pass
		@unittest.skip(reason='Levit does not output attentions'		)
		def       UpperCAmelCase__							(     self		)					->			List[str]:




									"""simple docstring"""





									pass
		def       UpperCAmelCase__							(     self		)					->			Union[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase						,			_UpperCAmelCase											=     self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																_UpperCAmelCase											=     model_class(_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase											=     inspect.signature(model.forward		)
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																_UpperCAmelCase											=     [*signature.parameters.keys()]

																_UpperCAmelCase											=     ['pixel_values']
																self.assertListEqual(arg_names[:1]     ,       _SCREAMING_SNAKE_CASE		)
		def       UpperCAmelCase__							(     self		)					->			int:




									"""simple docstring"""





									def check_hidden_states_output(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		):
																_UpperCAmelCase											=     model_class(_SCREAMING_SNAKE_CASE		)
																model.to(_SCREAMING_SNAKE_CASE		)
																model.eval()

																with torch.no_grad():
																							_UpperCAmelCase											=     model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)		)

																_UpperCAmelCase											=     outputs.hidden_states

																_UpperCAmelCase											=     len(self.model_tester.depths		) + 1
																self.assertEqual(len(_SCREAMING_SNAKE_CASE		)     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     (self.model_tester.image_size, self.model_tester.image_size)
																_UpperCAmelCase						,			_UpperCAmelCase											=     image_size[0], image_size[1]
																for _ in range(4		):
																							_UpperCAmelCase											=     floor(
																							    (
																							        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																							        / self.model_tester.stride
																							    )
																							    + 1		)
																							_UpperCAmelCase											=     floor(
																							    (
																							        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																							        / self.model_tester.stride
																							    )
																							    + 1		)
																# verify the first hidden states (first block)
																self.assertListEqual(
																    list(hidden_states[0].shape[-2:]		)     ,       [
																        height * width,
																        self.model_tester.hidden_sizes[0],
																    ]     ,       )

									_UpperCAmelCase						,			_UpperCAmelCase											=     self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																_UpperCAmelCase											=     True
																check_hidden_states_output(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																_UpperCAmelCase											=     True

																check_hidden_states_output(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
		@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'		)
		def       UpperCAmelCase__							(     self		)					->			Tuple:




									"""simple docstring"""





									pass
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE=False		)					->			Dict:




									"""simple docstring"""





									_UpperCAmelCase											=     super()._prepare_for_class(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       return_labels=_SCREAMING_SNAKE_CASE		)

									if return_labels:
																if model_class.__name__ == "LevitForImageClassificationWithTeacher":
																							del inputs_dict["labels"]

									return inputs_dict
		def       UpperCAmelCase__							(     self		)					->			Any:




									"""simple docstring"""





									_UpperCAmelCase											=     self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE		)
		def       UpperCAmelCase__							(     self		)					->			List[Any]:




									"""simple docstring"""





									_UpperCAmelCase											=     self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE		)
		def       UpperCAmelCase__							(     self		)					->			Dict:




									"""simple docstring"""





									if not self.model_tester.is_training:
																return

									_UpperCAmelCase						,			_UpperCAmelCase											=     self.model_tester.prepare_config_and_inputs_for_common()
									_UpperCAmelCase											=     True

									for model_class in self.all_model_classes:
																# LevitForImageClassificationWithTeacher supports inference-only
																if (
																    model_class in get_values(_SCREAMING_SNAKE_CASE		)
																    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																):
																							continue
																_UpperCAmelCase											=     model_class(_SCREAMING_SNAKE_CASE		)
																model.to(_SCREAMING_SNAKE_CASE		)
																model.train()
																_UpperCAmelCase											=     self._prepare_for_class(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       return_labels=_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase											=     model(**_SCREAMING_SNAKE_CASE		).loss
																loss.backward()
		def       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase						,			_UpperCAmelCase											=     self.model_tester.prepare_config_and_inputs_for_common()
									if not self.model_tester.is_training:
																return

									_UpperCAmelCase											=     False
									_UpperCAmelCase											=     True

									for model_class in self.all_model_classes:
																if model_class in get_values(_SCREAMING_SNAKE_CASE		) or not model_class.supports_gradient_checkpointing:
																							continue
																# LevitForImageClassificationWithTeacher supports inference-only
																if model_class.__name__ == "LevitForImageClassificationWithTeacher":
																							continue
																_UpperCAmelCase											=     model_class(_SCREAMING_SNAKE_CASE		)
																model.gradient_checkpointing_enable()
																model.to(_SCREAMING_SNAKE_CASE		)
																model.train()
																_UpperCAmelCase											=     self._prepare_for_class(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       return_labels=_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase											=     model(**_SCREAMING_SNAKE_CASE		).loss
																loss.backward()
		def       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase						,			_UpperCAmelCase											=     self.model_tester.prepare_config_and_inputs_for_common()

									_UpperCAmelCase											=     [
									    {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
									    {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
									    {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
									]

									for model_class in self.all_model_classes:
																if (
																    model_class
																    not in [
																        *get_values(_SCREAMING_SNAKE_CASE		),
																    ]
																    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																):
																							continue

																for problem_type in problem_types:
																							with self.subTest(msg=f'''Testing {model_class} with {problem_type["title"]}'''		):
																														_UpperCAmelCase											=     problem_type['title']
																														_UpperCAmelCase											=     problem_type['num_labels']

																														_UpperCAmelCase											=     model_class(_SCREAMING_SNAKE_CASE		)
																														model.to(_SCREAMING_SNAKE_CASE		)
																														model.train()

																														_UpperCAmelCase											=     self._prepare_for_class(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       return_labels=_SCREAMING_SNAKE_CASE		)

																														if problem_type["num_labels"] > 1:
																																					_UpperCAmelCase											=     inputs['labels'].unsqueeze(1		).repeat(1     ,       problem_type['num_labels']		)

																														_UpperCAmelCase											=     inputs['labels'].to(problem_type['dtype']		)

																														# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																														# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																														# they have the same size." which is a symptom something in wrong for the regression problem.
																														# See https://github.com/huggingface/transformers/issues/11780
																														with warnings.catch_warnings(record=_SCREAMING_SNAKE_CASE		) as warning_list:
																																					_UpperCAmelCase											=     model(**_SCREAMING_SNAKE_CASE		).loss
																														for w in warning_list:
																																					if "Using a target size that is different to the input size" in str(w.message		):
																																												raise ValueError(
																																												    f'''Something is going wrong in the regression problem: intercepted {w.message}'''		)

																														loss.backward()






		@slow
		def       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCAmelCase											=     LevitModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)



def 			lowerCAmelCase__					(     )    ->						List[Any]:


							'''simple docstring'''





							_UpperCAmelCase											=     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
							return image







@require_torch
@require_vision
class 						__a (							unittest.TestCase     ):
		@cached_property
		def       UpperCAmelCase__							(     self		)					->			Optional[Any]:




									"""simple docstring"""





									return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)






		@slow
		def       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase											=     LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(
									    _SCREAMING_SNAKE_CASE		)

									_UpperCAmelCase											=     self.default_image_processor
									_UpperCAmelCase											=     prepare_img()
									_UpperCAmelCase											=     image_processor(images=_SCREAMING_SNAKE_CASE     ,       return_tensors='pt'		).to(_SCREAMING_SNAKE_CASE		)

									# forward pass
									with torch.no_grad():
																_UpperCAmelCase											=     model(**_SCREAMING_SNAKE_CASE		)

									# verify the logits
									_UpperCAmelCase											=     torch.Size((1, 1000)		)
									self.assertEqual(outputs.logits.shape     ,       _SCREAMING_SNAKE_CASE		)

									_UpperCAmelCase											=     torch.tensor([1.0448, -0.3745, -1.8317]		).to(_SCREAMING_SNAKE_CASE		)

									self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,       _SCREAMING_SNAKE_CASE     ,       atol=1e-4		)		)




from __future__ import annotations

def 			lowerCAmelCase__					(     a__:						str     ,    a__:						str			)    ->						bool:


							'''simple docstring'''





							_UpperCAmelCase											=     get_failure_array(a__			)

							# 2) Step through text searching for pattern
							_UpperCAmelCase						,			_UpperCAmelCase											=     0, 0  # index into text, pattern
							while i < len(a__			):
														if pattern[j] == text[i]:
																					if j == (len(a__			) - 1):
																												return True
																					j += 1

														# if this is a prefix in our pattern
														# just go back far enough to continue
														elif j > 0:
																					_UpperCAmelCase											=     failure[j - 1]
																					continue
														i += 1
							return False

def 			lowerCAmelCase__					(     a__:						str			)    ->						list[int]:


							'''simple docstring'''





							_UpperCAmelCase											=     [0]
							_UpperCAmelCase											=     0
							_UpperCAmelCase											=     1
							while j < len(a__			):
														if pattern[i] == pattern[j]:
																					i += 1
														elif i > 0:
																					_UpperCAmelCase											=     failure[i - 1]
																					continue
														j += 1
														failure.append(a__			)
							return failure


if __name__ == "__main__":
		# Test 1)
		lowerCAmelCase__    :List[Any]       =				'''abc1abc12'''
		lowerCAmelCase__    :Optional[int]       =				'''alskfjaldsabc1abc1abc12k23adsfabcabc'''
		lowerCAmelCase__    :int       =				'''alskfjaldsk23adsfabcabc'''
		assert kmp(pattern, texta) and not kmp(pattern, texta)

		# Test 2)
		lowerCAmelCase__    :List[str]       =				'''ABABX'''
		lowerCAmelCase__    :int       =				'''ABABZABABYABABX'''
		assert kmp(pattern, text)

		# Test 3)
		lowerCAmelCase__    :int       =				'''AAAB'''
		lowerCAmelCase__    :Any       =				'''ABAAAAAB'''
		assert kmp(pattern, text)

		# Test 4)
		lowerCAmelCase__    :Union[str, Any]       =				'''abcdabcy'''
		lowerCAmelCase__    :Any       =				'''abcxabcdabxabcdabcdabcy'''
		assert kmp(pattern, text)

		# Test 5)
		lowerCAmelCase__    :List[Any]       =				'''aabaabaaa'''
		assert get_failure_array(pattern) == [0, 1, 0, 1, 2, 3, 4, 5, 2]
