

"""simple docstring"""



import collections
import inspect
import unittest

from transformers import SwinvaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
 import torch
 from torch import nn

 from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
 from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor



class 					a						:



    """simple docstring"""



    def __init__(     self: Optional[int]    ,						UpperCamelCase: Any    ,						UpperCamelCase: Optional[int]=13    ,						UpperCamelCase: List[str]=32    ,						UpperCamelCase: List[str]=2    ,						UpperCamelCase: int=3    ,						UpperCamelCase: Tuple=16    ,						UpperCamelCase: Optional[Any]=[1, 2, 1]    ,						UpperCamelCase: List[str]=[2, 2, 4]    ,						UpperCamelCase: Tuple=2    ,						UpperCamelCase: Tuple=2.0    ,						UpperCamelCase: Dict=True    ,						UpperCamelCase: int=0.0    ,						UpperCamelCase: str=0.0    ,						UpperCamelCase: Tuple=0.1    ,						UpperCamelCase: List[Any]="gelu"    ,						UpperCamelCase: Union[str, Any]=False    ,						UpperCamelCase: Dict=True    ,						UpperCamelCase: Any=0.02    ,						UpperCamelCase: Optional[int]=1e-5    ,						UpperCamelCase: int=True    ,						UpperCamelCase: Optional[Any]=None    ,						UpperCamelCase: List[str]=True    ,						UpperCamelCase: Union[str, Any]=10    ,						UpperCamelCase: int=8    ,						):






         """simple docstring"""


         A__										=  parent
         A__										=  batch_size
         A__										=  image_size
         A__										=  patch_size
         A__										=  num_channels
         A__										=  embed_dim
         A__										=  depths
         A__										=  num_heads
         A__										=  window_size
         A__										=  mlp_ratio
         A__										=  qkv_bias
         A__										=  hidden_dropout_prob
         A__										=  attention_probs_dropout_prob
         A__										=  drop_path_rate
         A__										=  hidden_act
         A__										=  use_absolute_embeddings
         A__										=  patch_norm
         A__										=  layer_norm_eps
         A__										=  initializer_range
         A__										=  is_training
         A__										=  scope
         A__										=  use_labels
         A__										=  type_sequence_label_size
         A__										=  encoder_stride

    def 				UpperCamelCase	(     self: List[Any]       ):






         """simple docstring"""


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

         A__										=  None
         if self.use_labels:
              A__										=  ids_tensor([self.batch_size]    ,						self.type_sequence_label_size       )

         A__										=  self.get_config()

         return config, pixel_values, labels

    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         return SwinvaConfig(
             image_size=self.image_size    ,						patch_size=self.patch_size    ,						num_channels=self.num_channels    ,						embed_dim=self.embed_dim    ,						depths=self.depths    ,						num_heads=self.num_heads    ,						window_size=self.window_size    ,						mlp_ratio=self.mlp_ratio    ,						qkv_bias=self.qkv_bias    ,						hidden_dropout_prob=self.hidden_dropout_prob    ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,						drop_path_rate=self.drop_path_rate    ,						hidden_act=self.hidden_act    ,						use_absolute_embeddings=self.use_absolute_embeddings    ,						path_norm=self.patch_norm    ,						layer_norm_eps=self.layer_norm_eps    ,						initializer_range=self.initializer_range    ,						encoder_stride=self.encoder_stride    ,						)

    def 				UpperCamelCase	(     self: str    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: Tuple       ):






         """simple docstring"""


         A__										=  SwinvaModel(config=UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()
         A__										=  model(UpperCamelCase       )

         A__										=  ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths       ) - 1))
         A__										=  int(config.embed_dim * 2 ** (len(config.depths       ) - 1)       )

         self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, expected_seq_len, expected_dim)       )

    def 				UpperCamelCase	(     self: Tuple    ,						UpperCamelCase: Any    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Tuple       ):






         """simple docstring"""


         A__										=  SwinvaForMaskedImageModeling(config=UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()
         A__										=  model(UpperCamelCase       )
         self.parent.assertEqual(
             result.logits.shape    ,						(self.batch_size, self.num_channels, self.image_size, self.image_size)       )

         # test greyscale images
         A__										=  1
         A__										=  SwinvaForMaskedImageModeling(UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()

         A__										=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
         A__										=  model(UpperCamelCase       )
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, 1, self.image_size, self.image_size)       )

    def 				UpperCamelCase	(     self: Dict    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: int    ,						UpperCamelCase: List[Any]       ):






         """simple docstring"""


         A__										=  self.type_sequence_label_size
         A__										=  SwinvaForImageClassification(UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()
         A__										=  model(UpperCamelCase    ,						labels=UpperCamelCase       )
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.type_sequence_label_size)       )





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






         """simple docstring"""


         A__										=  self.prepare_config_and_inputs()
         A__			,				A__			,				A__										=  config_and_inputs
         A__										=  {"""pixel_values""": pixel_values}
         return config, inputs_dict



@require_torch
class 					a						(       _lowerCamelCase,	_lowerCamelCase,	unittest.TestCase				):



    """simple docstring"""



    UpperCAmelCase						 =					(
        (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
    )
    UpperCAmelCase						 =					(
        {"feature-extraction": SwinvaModel, "image-classification": SwinvaForImageClassification}
        if is_torch_available()
        else {}
    )

    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False

    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         A__										=  SwinvaModelTester(self       )
         A__										=  ConfigTester(self    ,						config_class=UpperCamelCase    ,						embed_dim=37       )

    def 				UpperCamelCase	(     self: int       ):






         """simple docstring"""


         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"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase       )

    @unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""       )
    def 				UpperCamelCase	(     self: List[Any]       ):






         """simple docstring"""


         pass

    @unittest.skip(reason="""Swinv2 does not use inputs_embeds"""       )
    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


         pass

    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
              A__										=  model_class(UpperCamelCase       )
              self.assertIsInstance(model.get_input_embeddings()    ,						(nn.Module)       )
              A__										=  model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(UpperCamelCase    ,						nn.Linear       )       )

    def 				UpperCamelCase	(     self: int       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()

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

              A__										=  ["""pixel_values"""]
              self.assertListEqual(arg_names[:1]    ,						UpperCamelCase       )

    def 				UpperCamelCase	(     self: List[str]       ):






         """simple docstring"""


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

         for model_class in self.all_model_classes:
              A__										=  True
              A__										=  False
              A__										=  True
              A__										=  model_class(UpperCamelCase       )
              model.to(UpperCamelCase       )
              model.eval()
              with torch.no_grad():
                   A__										=  model(**self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )
              A__										=  outputs.attentions
              A__										=  len(self.model_tester.depths       )
              self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              A__										=  True
              A__										=  config.window_size**2
              A__										=  model_class(UpperCamelCase       )
              model.to(UpperCamelCase       )
              model.eval()
              with torch.no_grad():
                   A__										=  model(**self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )
              A__										=  outputs.attentions
              self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

              self.assertListEqual(
                  list(attentions[0].shape[-3:]       )    ,						[self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,						)
              A__										=  len(UpperCamelCase       )

              # Check attention is always last and order is fine
              A__										=  True
              A__										=  True
              A__										=  model_class(UpperCamelCase       )
              model.to(UpperCamelCase       )
              model.eval()
              with torch.no_grad():
                   A__										=  model(**self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )

              if hasattr(self.model_tester    ,						"""num_hidden_states_types"""       ):
                   A__										=  self.model_tester.num_hidden_states_types
              else:
                   # also another +1 for reshaped_hidden_states
                   A__										=  2
              self.assertEqual(out_len + added_hidden_states    ,						len(UpperCamelCase       )       )

              A__										=  outputs.attentions

              self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

              self.assertListEqual(
                  list(self_attentions[0].shape[-3:]       )    ,						[self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,						)

    def 				UpperCamelCase	(     self: Union[str, Any]    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Dict    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: Union[str, Any]       ):






         """simple docstring"""


         A__										=  model_class(UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()

         with torch.no_grad():
              A__										=  model(**self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )

         A__										=  outputs.hidden_states

         A__										=  getattr(
             self.model_tester    ,						"""expected_num_hidden_layers"""    ,						len(self.model_tester.depths       ) + 1       )
         self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

         # Swinv2 has a different seq_length
         A__										=  (
             config.patch_size
             if isinstance(config.patch_size    ,						collections.abc.Iterable       )
             else (config.patch_size, config.patch_size)
         )

         A__										=  (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

         self.assertListEqual(
             list(hidden_states[0].shape[-2:]       )    ,						[num_patches, self.model_tester.embed_dim]    ,						)

         A__										=  outputs.reshaped_hidden_states
         self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

         A__			,				A__			,				A__			,				A__										=  reshaped_hidden_states[0].shape
         A__										=  (
             reshaped_hidden_states[0].view(UpperCamelCase    ,						UpperCamelCase    ,						height * width       ).permute(0    ,						2    ,						1       )
         )
         self.assertListEqual(
             list(reshaped_hidden_states.shape[-2:]       )    ,						[num_patches, self.model_tester.embed_dim]    ,						)

    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()

         A__										=  (
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size    ,						collections.abc.Iterable       )
             else (self.model_tester.image_size, self.model_tester.image_size)
         )

         for model_class in self.all_model_classes:
              A__										=  True
              self.check_hidden_states_output(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase       )

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

              self.check_hidden_states_output(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase       )

    def 				UpperCamelCase	(     self: int       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()
         A__										=  3

         A__										=  (
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size    ,						collections.abc.Iterable       )
             else (self.model_tester.image_size, self.model_tester.image_size)
         )
         A__										=  (
             config.patch_size
             if isinstance(config.patch_size    ,						collections.abc.Iterable       )
             else (config.patch_size, config.patch_size)
         )

         A__										=  image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         A__										=  image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes:
              A__										=  True
              self.check_hidden_states_output(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						(padded_height, padded_width)       )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              A__										=  True
              self.check_hidden_states_output(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						(padded_height, padded_width)       )

    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*UpperCamelCase       )

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






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*UpperCamelCase       )

    @slow
    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              A__										=  SwinvaModel.from_pretrained(UpperCamelCase       )
              self.assertIsNotNone(UpperCamelCase       )





    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()

         A__										=  _config_zero_init(UpperCamelCase       )
         for model_class in self.all_model_classes:
              A__										=  model_class(config=UpperCamelCase       )
              for name, param in model.named_parameters():
                   if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
                        self.assertIn(
                            ((param.data.mean() * 1e9).round() / 1e9).item()    ,						[0.0, 1.0]    ,						msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""    ,						)



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



    """simple docstring"""



    @cached_property
    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         return (
             AutoImageProcessor.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""       )
             if is_vision_available()
             else None
         )





    @slow
    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         A__										=  SwinvaForImageClassification.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""       ).to(
             UpperCamelCase       )
         A__										=  self.default_image_processor

         A__										=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
         A__										=  image_processor(images=UpperCamelCase    ,						return_tensors="""pt"""       ).to(UpperCamelCase       )

         # forward pass
         with torch.no_grad():
              A__										=  model(**UpperCamelCase       )

         # verify the logits
         A__										=  torch.Size((1, 10_00)       )
         self.assertEqual(outputs.logits.shape    ,						UpperCamelCase       )
         A__										=  torch.tensor([-0.3_947, -0.4_306, 0.0_026]       ).to(UpperCamelCase       )
         self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,						UpperCamelCase    ,						atol=1e-4       )       )









"""simple docstring"""



from __future__ import annotations



class 					a						:



    """simple docstring"""



    def __init__(     self: Any    ,						UpperCamelCase: str    ,						UpperCamelCase: str       ):






         """simple docstring"""


         A__			,				A__										=  text, pattern
         A__			,				A__										=  len(UpperCamelCase       ), len(UpperCamelCase       )

    def 				UpperCamelCase	(     self: Dict    ,						UpperCamelCase: str       ):






         """simple docstring"""


         for i in range(self.patLen - 1    ,						-1    ,						-1       ):
              if char == self.pattern[i]:
                   return i
         return -1

    def 				UpperCamelCase	(     self: str    ,						UpperCamelCase: int       ):






         """simple docstring"""


         for i in range(self.patLen - 1    ,						-1    ,						-1       ):
              if self.pattern[i] != self.text[current_pos + i]:
                   return current_pos + i
         return -1





    def 				UpperCamelCase	(     self: List[Any]       ):






         """simple docstring"""


         A__										=  []
         for i in range(self.textLen - self.patLen + 1       ):
              A__										=  self.mismatch_in_text(UpperCamelCase       )
              if mismatch_index == -1:
                   positions.append(UpperCamelCase       )
              else:
                   A__										=  self.match_in_pattern(self.text[mismatch_index]       )
                   A__										=  (
                       mismatch_index - match_index
                   )  # shifting index lgtm [py/multiple-definition]
         return positions

SCREAMING_SNAKE_CASE_					:	List[Any]							  =						'ABAABA'
SCREAMING_SNAKE_CASE_					:	List[Any]							  =						'AB'
SCREAMING_SNAKE_CASE_					:	Union[str, Any]							  =						BoyerMooreSearch(text, pattern)
SCREAMING_SNAKE_CASE_					:	int							  =						bms.bad_character_heuristic()

if len(positions) == 0:
 print('No match found')
else:
 print('Pattern found in following positions: ')
 print(positions)






