


'''simple docstring'''


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 						__lowerCAmelCase		(				__SCREAMING_SNAKE_CASE     ):


  '''simple docstring'''







  def 							_a				(				self			:							Any			):

        '''simple docstring'''




        A_    :	List[Any]							 =					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 						__lowerCAmelCase		:


  '''simple docstring'''







  def __init__(				self			:							List[str]						,_a			:							str						,_a			:							int=13						,_a			:							Union[str, Any]=64						,_a			:							List[str]=3						,_a			:							Union[str, Any]=3						,_a			:							Tuple=2						,_a			:							List[Any]=1						,_a			:							Optional[Any]=16						,_a			:							Any=[128, 256, 384]						,_a			:							int=[4, 6, 8]						,_a			:							Optional[Any]=[2, 3, 4]						,_a			:							int=[16, 16, 16]						,_a			:							Union[str, Any]=0						,_a			:							Union[str, Any]=[2, 2, 2]						,_a			:							Optional[int]=[2, 2, 2]						,_a			:							Any=0.02						,_a			:							List[str]=True						,_a			:							int=True						,_a			:							str=2						,):

        '''simple docstring'''




        A_    :	Dict							 =					parent
        A_    :	List[Any]							 =					batch_size
        A_    :	Any							 =					image_size
        A_    :	List[str]							 =					num_channels
        A_    :	Optional[Any]							 =					kernel_size
        A_    :	Union[str, Any]							 =					stride
        A_    :	Optional[Any]							 =					padding
        A_    :	Union[str, Any]							 =					hidden_sizes
        A_    :	List[str]							 =					num_attention_heads
        A_    :	str							 =					depths
        A_    :	List[str]							 =					key_dim
        A_    :	Tuple							 =					drop_path_rate
        A_    :	List[str]							 =					patch_size
        A_    :	Dict							 =					attention_ratio
        A_    :	Union[str, Any]							 =					mlp_ratio
        A_    :	str							 =					initializer_range
        A_    :	List[str]							 =					[
            ["""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],
        ]
        A_    :	Any							 =					is_training
        A_    :	Tuple							 =					use_labels
        A_    :	List[str]							 =					num_labels
        A_    :	Optional[Any]							 =					initializer_range






  def 							_a				(				self			:							int			):

        '''simple docstring'''




        A_    :	List[Any]							 =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

        A_    :	List[Any]							 =					None
        if self.use_labels:
              A_    :	Dict							 =					ids_tensor([self.batch_size]						,self.num_labels			)

        A_    :	List[str]							 =					self.get_config()
        return config, pixel_values, labels






  def 							_a				(				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 							_a				(				self			:							int						,_a			:							List[str]						,_a			:							int						,_a			:							Dict			):

        '''simple docstring'''




        A_    :	str							 =					LevitModel(config=_SCREAMING_SNAKE_CASE			)
        model.to(_SCREAMING_SNAKE_CASE			)
        model.eval()
        A_    :	str							 =					model(_SCREAMING_SNAKE_CASE			)
        A_    :	Union[str, Any]							 =					(self.image_size, self.image_size)
        A_ ,       A_    :	Any							 =					image_size[0], image_size[1]
        for _ in range(4			):
              A_    :	Union[str, Any]							 =					floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1			)
              A_    :	Optional[int]							 =					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 							_a				(				self			:							Tuple						,_a			:							int						,_a			:							List[str]						,_a			:							Any			):

        '''simple docstring'''




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






  def 							_a				(				self			:							Tuple			):

        '''simple docstring'''




        A_    :	List[Any]							 =					self.prepare_config_and_inputs()
        A_ ,       A_ ,       A_    :	Optional[int]							 =					config_and_inputs
        A_    :	Dict							 =					{"""pixel_values""": pixel_values}
        return config, inputs_dict







@require_torch
class 						__lowerCAmelCase		(				__SCREAMING_SNAKE_CASE	,			__SCREAMING_SNAKE_CASE	,			unittest.TestCase     ):


  '''simple docstring'''







  a_	       =				(
      (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
      if is_torch_available()
      else ()
  )
  a_	       =				(
      {
          'feature-extraction': LevitModel,
          'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
      }
      if is_torch_available()
      else {}
  )

  a_	       =				False
  a_	       =				False
  a_	       =				False
  a_	       =				False
  a_	       =				False






  def 							_a				(				self			:							List[str]			):

        '''simple docstring'''




        A_    :	Any							 =					LevitModelTester(self			)
        A_    :	Dict							 =					ConfigTester(self						,config_class=_SCREAMING_SNAKE_CASE						,has_text_modality=_SCREAMING_SNAKE_CASE						,hidden_size=37			)






  def 							_a				(				self			:							Optional[Any]			):

        '''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 							_a				(				self			:							int			):

        '''simple docstring'''




        return






  @unittest.skip(reason="""Levit does not use inputs_embeds"""			)
  def 							_a				(				self			:							Any			):

        '''simple docstring'''




        pass






  @unittest.skip(reason="""Levit does not support input and output embeddings"""			)
  def 							_a				(				self			:							Union[str, Any]			):

        '''simple docstring'''




        pass






  @unittest.skip(reason="""Levit does not output attentions"""			)
  def 							_a				(				self			:							Optional[Any]			):

        '''simple docstring'''




        pass






  def 							_a				(				self			:							Tuple			):

        '''simple docstring'''




        A_ ,       A_    :	str							 =					self.model_tester.prepare_config_and_inputs_for_common()

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

              A_    :	str							 =					["""pixel_values"""]
              self.assertListEqual(arg_names[:1]						,_SCREAMING_SNAKE_CASE			)






  def 							_a				(				self			:							Optional[int]			):

        '''simple docstring'''




        def check_hidden_states_output(_a			:							List[Any]						,_a			:							Dict						,_a			:							int			):
              A_    :	Optional[int]							 =					model_class(_SCREAMING_SNAKE_CASE			)
              model.to(_SCREAMING_SNAKE_CASE			)
              model.eval()

              with torch.no_grad():
                    A_    :	Union[str, Any]							 =					model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE			)			)

              A_    :	str							 =					outputs.hidden_states

              A_    :	Optional[Any]							 =					len(self.model_tester.depths			) + 1
              self.assertEqual(len(_SCREAMING_SNAKE_CASE			)						,_SCREAMING_SNAKE_CASE			)

              A_    :	Dict							 =					(self.model_tester.image_size, self.model_tester.image_size)
              A_ ,       A_    :	Dict							 =					image_size[0], image_size[1]
              for _ in range(4			):
                    A_    :	Any							 =					floor(
                        (
                            (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                            / self.model_tester.stride
                        )
                        + 1			)
                    A_    :	Dict							 =					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],
                  ]						,)

        A_ ,       A_    :	Union[str, Any]							 =					self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              A_    :	Tuple							 =					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"]
              A_    :	Union[str, Any]							 =					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 							_a				(				self			:							str			):

        '''simple docstring'''




        pass






  def 							_a				(				self			:							str						,_a			:							List[Any]						,_a			:							Optional[int]						,_a			:							Tuple=False			):

        '''simple docstring'''




        A_    :	Optional[int]							 =					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 							_a				(				self			:							str			):

        '''simple docstring'''




        A_    :	List[Any]							 =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE			)






  def 							_a				(				self			:							List[str]			):

        '''simple docstring'''




        A_    :	Union[str, Any]							 =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE			)






  def 							_a				(				self			:							Optional[Any]			):

        '''simple docstring'''




        if not self.model_tester.is_training:
              return

        A_ ,       A_    :	Tuple							 =					self.model_tester.prepare_config_and_inputs_for_common()
        A_    :	List[str]							 =					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
              A_    :	Optional[Any]							 =					model_class(_SCREAMING_SNAKE_CASE			)
              model.to(_SCREAMING_SNAKE_CASE			)
              model.train()
              A_    :	Tuple							 =					self._prepare_for_class(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE						,return_labels=_SCREAMING_SNAKE_CASE			)
              A_    :	List[str]							 =					model(**_SCREAMING_SNAKE_CASE			).loss
              loss.backward()






  def 							_a				(				self			:							int			):

        '''simple docstring'''




        A_ ,       A_    :	List[Any]							 =					self.model_tester.prepare_config_and_inputs_for_common()
        if not self.model_tester.is_training:
              return

        A_    :	List[str]							 =					False
        A_    :	Dict							 =					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
              A_    :	Tuple							 =					model_class(_SCREAMING_SNAKE_CASE			)
              model.gradient_checkpointing_enable()
              model.to(_SCREAMING_SNAKE_CASE			)
              model.train()
              A_    :	str							 =					self._prepare_for_class(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE						,return_labels=_SCREAMING_SNAKE_CASE			)
              A_    :	List[Any]							 =					model(**_SCREAMING_SNAKE_CASE			).loss
              loss.backward()






  def 							_a				(				self			:							int			):

        '''simple docstring'''




        A_ ,       A_    :	Optional[int]							 =					self.model_tester.prepare_config_and_inputs_for_common()

        A_    :	Union[str, Any]							 =					[
            {"""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"]}'			):
                          A_    :	Union[str, Any]							 =					problem_type["""title"""]
                          A_    :	str							 =					problem_type["""num_labels"""]

                          A_    :	int							 =					model_class(_SCREAMING_SNAKE_CASE			)
                          model.to(_SCREAMING_SNAKE_CASE			)
                          model.train()

                          A_    :	Optional[Any]							 =					self._prepare_for_class(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE						,return_labels=_SCREAMING_SNAKE_CASE			)

                          if problem_type["num_labels"] > 1:
                                A_    :	Union[str, Any]							 =					inputs["""labels"""].unsqueeze(1			).repeat(1						,problem_type["""num_labels"""]			)

                          A_    :	Union[str, Any]							 =					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:
                                A_    :	str							 =					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 							_a				(				self			:							Union[str, Any]			):

        '''simple docstring'''




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







def   lowerCamelCase       (   ):
      A_    :	List[str]							 =					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""")
      return image






@require_torch
@require_vision
class 						__lowerCAmelCase		(				unittest.TestCase     ):


  '''simple docstring'''







  @cached_property
  def 							_a				(				self			:							List[str]			):

        '''simple docstring'''




        return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)






  @slow
  def 							_a				(				self			:							str			):

        '''simple docstring'''




        A_    :	Optional[int]							 =					LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]			).to(
            _SCREAMING_SNAKE_CASE			)

        A_    :	Any							 =					self.default_image_processor
        A_    :	List[Any]							 =					prepare_img()
        A_    :	str							 =					image_processor(images=_SCREAMING_SNAKE_CASE						,return_tensors="""pt"""			).to(_SCREAMING_SNAKE_CASE			)

        # forward pass
        with torch.no_grad():
              A_    :	Union[str, Any]							 =					model(**_SCREAMING_SNAKE_CASE			)

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

        A_    :	List[str]							 =					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]
