






import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
  from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor





class       __a  :







 def __init__(		self :       Optional[int]							,       SCREAMING_SNAKE_CASE :       Optional[Any]							,       SCREAMING_SNAKE_CASE :       List[str]=13							,       SCREAMING_SNAKE_CASE :       str=32							,       SCREAMING_SNAKE_CASE :       Dict=3							,       SCREAMING_SNAKE_CASE :       Optional[int]=4							,       SCREAMING_SNAKE_CASE :       Optional[int]=[10, 20, 30, 40]							,       SCREAMING_SNAKE_CASE :       str=[2, 2, 3, 2]							,       SCREAMING_SNAKE_CASE :       List[Any]=True							,       SCREAMING_SNAKE_CASE :       Any=True							,       SCREAMING_SNAKE_CASE :       List[Any]=37							,       SCREAMING_SNAKE_CASE :       Optional[int]="gelu"							,       SCREAMING_SNAKE_CASE :       int=10							,       SCREAMING_SNAKE_CASE :       Any=0.0_2							,       SCREAMING_SNAKE_CASE :       str=["stage2", "stage3", "stage4"]							,       SCREAMING_SNAKE_CASE :       List[Any]=[2, 3, 4]							,       SCREAMING_SNAKE_CASE :       Union[str, Any]=None							,       ):


      '''simple docstring'''






      UpperCamelCase__      :       Union[str, Any]	    =  parent
      UpperCamelCase__      :       Tuple	    =  batch_size
      UpperCamelCase__      :       Any	    =  image_size
      UpperCamelCase__      :       Dict	    =  num_channels
      UpperCamelCase__      :       Union[str, Any]	    =  num_stages
      UpperCamelCase__      :       List[str]	    =  hidden_sizes
      UpperCamelCase__      :       Tuple	    =  depths
      UpperCamelCase__      :       List[str]	    =  is_training
      UpperCamelCase__      :       Dict	    =  use_labels
      UpperCamelCase__      :       Optional[Any]	    =  intermediate_size
      UpperCamelCase__      :       Any	    =  hidden_act
      UpperCamelCase__      :       Optional[int]	    =  num_labels
      UpperCamelCase__      :       Any	    =  initializer_range
      UpperCamelCase__      :       Optional[int]	    =  out_features
      UpperCamelCase__      :       Optional[Any]	    =  out_indices
      UpperCamelCase__      :       Any	    =  scope







 def  __lowercase (		self :       Any						):


      '''simple docstring'''






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

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

      UpperCamelCase__      :       Union[str, Any]	    =  self.get_config()

      return config, pixel_values, labels







 def  __lowercase (		self :       Tuple						):


      '''simple docstring'''






      return ConvNextVaConfig(
          num_channels=self.num_channels							,       hidden_sizes=self.hidden_sizes							,       depths=self.depths							,       num_stages=self.num_stages							,       hidden_act=self.hidden_act							,       is_decoder=lowerCAmelCase__							,       initializer_range=self.initializer_range							,       out_features=self.out_features							,       out_indices=self.out_indices							,       num_labels=self.num_labels							,       )







 def  __lowercase (		self :       Dict							,       SCREAMING_SNAKE_CASE :       Optional[Any]							,       SCREAMING_SNAKE_CASE :       Optional[int]							,       SCREAMING_SNAKE_CASE :       Optional[int]						):


      '''simple docstring'''






      UpperCamelCase__      :       Union[str, Any]	    =  ConvNextVaModel(config=lowerCAmelCase__						)
      model.to(lowerCAmelCase__						)
      model.eval()
      UpperCamelCase__      :       Any	    =  model(lowerCAmelCase__						)
      # expected last hidden states: B, C, H // 32, W // 32
      self.parent.assertEqual(
          result.last_hidden_state.shape							,       (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)							,       )







 def  __lowercase (		self :       Tuple							,       SCREAMING_SNAKE_CASE :       int							,       SCREAMING_SNAKE_CASE :       List[Any]							,       SCREAMING_SNAKE_CASE :       List[Any]						):


      '''simple docstring'''






      UpperCamelCase__      :       Optional[int]	    =  ConvNextVaForImageClassification(lowerCAmelCase__						)
      model.to(lowerCAmelCase__						)
      model.eval()
      UpperCamelCase__      :       Union[str, Any]	    =  model(lowerCAmelCase__							,       labels=lowerCAmelCase__						)
      self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.num_labels)						)







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


      '''simple docstring'''






      UpperCamelCase__      :       Optional[Any]	    =  ConvNextVaBackbone(config=lowerCAmelCase__						)
      model.to(lowerCAmelCase__						)
      model.eval()
      UpperCamelCase__      :       str	    =  model(lowerCAmelCase__						)

      # verify hidden states
      self.parent.assertEqual(len(result.feature_maps						)							,       len(config.out_features						)						)
      self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,       [self.batch_size, self.hidden_sizes[1], 4, 4]						)

      # verify channels
      self.parent.assertEqual(len(model.channels						)							,       len(config.out_features						)						)
      self.parent.assertListEqual(model.channels							,       config.hidden_sizes[1:]						)

      # verify backbone works with out_features=None
      UpperCamelCase__      :       Dict	    =  None
      UpperCamelCase__      :       Optional[int]	    =  ConvNextVaBackbone(config=lowerCAmelCase__						)
      model.to(lowerCAmelCase__						)
      model.eval()
      UpperCamelCase__      :       Optional[Any]	    =  model(lowerCAmelCase__						)

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps						)							,       1						)
      self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,       [self.batch_size, self.hidden_sizes[-1], 1, 1]						)

      # verify channels
      self.parent.assertEqual(len(model.channels						)							,       1						)
      self.parent.assertListEqual(model.channels							,       [config.hidden_sizes[-1]]						)







 def  __lowercase (		self :       Any						):


      '''simple docstring'''






      UpperCamelCase__      :       List[str]	    =  self.prepare_config_and_inputs()
      UpperCamelCase__      :       int	    =  config_and_inputs
      UpperCamelCase__      :       Union[str, Any]	    =  {"pixel_values": pixel_values}
      return config, inputs_dict







 def  __lowercase (		self :       Tuple						):


      '''simple docstring'''






      UpperCamelCase__      :       Dict	    =  self.prepare_config_and_inputs()
      UpperCamelCase__      :       str	    =  config_and_inputs
      UpperCamelCase__      :       str	    =  {"pixel_values": pixel_values, "labels": labels}
      return config, inputs_dict







@require_torch
class       __a  (   A__	,       A__	,       unittest.TestCase	):
 _lowerCAmelCase	:	List[Any]				=			(
     (
         ConvNextVaModel,
         ConvNextVaForImageClassification,
         ConvNextVaBackbone,
     )
     if is_torch_available()
     else ()
 )
 _lowerCAmelCase	:	List[Any]				=			(
     {'''feature-extraction''': ConvNextVaModel, '''image-classification''': ConvNextVaForImageClassification}
     if is_torch_available()
     else {}
 )

 _lowerCAmelCase	:	Optional[Any]				=			False
 _lowerCAmelCase	:	List[str]				=			False
 _lowerCAmelCase	:	List[Any]				=			False
 _lowerCAmelCase	:	Optional[Any]				=			False
 _lowerCAmelCase	:	Union[str, Any]				=			False







 def  __lowercase (		self :       List[str]						):


      '''simple docstring'''






      UpperCamelCase__      :       Optional[Any]	    =  ConvNextVaModelTester(self						)
      UpperCamelCase__      :       Tuple	    =  ConfigTester(self							,       config_class=lowerCAmelCase__							,       has_text_modality=lowerCAmelCase__							,       hidden_size=37						)







 def  __lowercase (		self :       Optional[int]						):


      '''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  __lowercase (		self :       Tuple						):


      '''simple docstring'''






      return







 @unittest.skip(reason="ConvNextV2 does not use inputs_embeds"						)
 def  __lowercase (		self :       List[str]						):


      '''simple docstring'''






      pass







 @unittest.skip(reason="ConvNextV2 does not support input and output embeddings"						)
 def  __lowercase (		self :       Optional[int]						):


      '''simple docstring'''






      pass







 @unittest.skip(reason="ConvNextV2 does not use feedforward chunking"						)
 def  __lowercase (		self :       Optional[Any]						):


      '''simple docstring'''






      pass







 def  __lowercase (		self :       Any						):


      '''simple docstring'''






      if not self.model_tester.is_training:
           return

      for model_class in self.all_model_classes:
           UpperCamelCase__      :       Optional[int]	    =  self.model_tester.prepare_config_and_inputs_with_labels()
           UpperCamelCase__      :       Dict	    =  True

           if model_class.__name__ in [
               *get_values(lowerCAmelCase__						),
               *get_values(lowerCAmelCase__						),
           ]:
                continue

           UpperCamelCase__      :       List[Any]	    =  model_class(lowerCAmelCase__						)
           model.to(lowerCAmelCase__						)
           model.train()
           UpperCamelCase__      :       int	    =  self._prepare_for_class(lowerCAmelCase__							,       lowerCAmelCase__							,       return_labels=lowerCAmelCase__						)
           UpperCamelCase__      :       Union[str, Any]	    =  model(**lowerCAmelCase__						).loss
           loss.backward()







 def  __lowercase (		self :       Tuple						):


      '''simple docstring'''






      if not self.model_tester.is_training:
           return

      for model_class in self.all_model_classes:
           UpperCamelCase__      :       Any	    =  self.model_tester.prepare_config_and_inputs_with_labels()
           UpperCamelCase__      :       Union[str, Any]	    =  False
           UpperCamelCase__      :       Optional[Any]	    =  True

           if (
               model_class.__name__
               in [*get_values(lowerCAmelCase__						), *get_values(lowerCAmelCase__						)]
               or not model_class.supports_gradient_checkpointing
           ):
                continue

           UpperCamelCase__      :       Union[str, Any]	    =  model_class(lowerCAmelCase__						)
           model.to(lowerCAmelCase__						)
           model.gradient_checkpointing_enable()
           model.train()
           UpperCamelCase__      :       Any	    =  self._prepare_for_class(lowerCAmelCase__							,       lowerCAmelCase__							,       return_labels=lowerCAmelCase__						)
           UpperCamelCase__      :       str	    =  model(**lowerCAmelCase__						).loss
           loss.backward()







 def  __lowercase (		self :       Any						):


      '''simple docstring'''






      UpperCamelCase__      :       Tuple	    =  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           UpperCamelCase__      :       Union[str, Any]	    =  model_class(lowerCAmelCase__						)
           UpperCamelCase__      :       Tuple	    =  inspect.signature(model.forward						)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           UpperCamelCase__      :       Dict	    =  [*signature.parameters.keys()]

           UpperCamelCase__      :       Optional[Any]	    =  ["pixel_values"]
           self.assertListEqual(arg_names[:1]							,       lowerCAmelCase__						)







 def  __lowercase (		self :       Optional[int]						):


      '''simple docstring'''






      UpperCamelCase__      :       Union[str, Any]	    =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase__						)







 def  __lowercase (		self :       List[str]						):


      '''simple docstring'''






      def check_hidden_states_output(SCREAMING_SNAKE_CASE :       Tuple							,       SCREAMING_SNAKE_CASE :       Optional[int]							,       SCREAMING_SNAKE_CASE :       Union[str, Any]						):
           UpperCamelCase__      :       Tuple	    =  model_class(lowerCAmelCase__						)
           model.to(lowerCAmelCase__						)
           model.eval()

           with torch.no_grad():
                UpperCamelCase__      :       Optional[Any]	    =  model(**self._prepare_for_class(lowerCAmelCase__							,       lowerCAmelCase__						)						)

           UpperCamelCase__      :       Optional[int]	    =  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

           UpperCamelCase__      :       List[str]	    =  self.model_tester.num_stages
           self.assertEqual(len(lowerCAmelCase__						)							,       expected_num_stages + 1						)

           # ConvNextV2's feature maps are of shape (batch_size, num_channels, height, width)
           self.assertListEqual(
               list(hidden_states[0].shape[-2:]						)							,       [self.model_tester.image_size // 4, self.model_tester.image_size // 4]							,       )

      UpperCamelCase__      :       str	    =  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           UpperCamelCase__      :       Dict	    =  True
           check_hidden_states_output(lowerCAmelCase__							,       lowerCAmelCase__							,       lowerCAmelCase__						)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           UpperCamelCase__      :       List[Any]	    =  True

           check_hidden_states_output(lowerCAmelCase__							,       lowerCAmelCase__							,       lowerCAmelCase__						)







 def  __lowercase (		self :       Tuple						):


      '''simple docstring'''






      UpperCamelCase__      :       Any	    =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__						)







 @slow
 def  __lowercase (		self :       Optional[int]						):


      '''simple docstring'''






      for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase__      :       Dict	    =  ConvNextVaModel.from_pretrained(lowerCAmelCase__						)
           self.assertIsNotNone(lowerCAmelCase__						)







def 		SCREAMING_SNAKE_CASE							( )			->     List[str]:
     UpperCamelCase__      :       Union[str, Any]	    =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
     return image





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







 @cached_property
 def  __lowercase (		self :       int						):


      '''simple docstring'''






      return AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224"						) if is_vision_available() else None







 @slow
 def  __lowercase (		self :       Any						):


      '''simple docstring'''






      UpperCamelCase__      :       Dict	    =  ConvNextVaForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224"						).to(lowerCAmelCase__						)

      UpperCamelCase__      :       str	    =  self.default_image_processor
      UpperCamelCase__      :       List[str]	    =  prepare_img()
      UpperCamelCase__      :       int	    =  preprocessor(images=lowerCAmelCase__							,       return_tensors="pt"						).to(lowerCAmelCase__						)

      # forward pass
      with torch.no_grad():
           UpperCamelCase__      :       List[Any]	    =  model(**lowerCAmelCase__						)

      # verify the logits
      UpperCamelCase__      :       List[Any]	    =  torch.Size((1, 10_00)						)
      self.assertEqual(outputs.logits.shape							,       lowerCAmelCase__						)

      UpperCamelCase__      :       Optional[int]	    =  torch.tensor([0.9_9_9_6, 0.1_9_6_6, -0.4_3_8_6]						).to(lowerCAmelCase__						)
      self.assertTrue(torch.allclose(outputs.logits[0, :3]							,       lowerCAmelCase__							,       atol=1e-4						)						)







import re







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     bool:
     UpperCamelCase__      :       Union[str, Any]	    =  re.compile(
         R"^(?:0|94|\+94|0{2}94)" R"7(0|1|2|4|5|6|7|8)" R"(-| |)" R"\d{7}$"      )

     return bool(re.search(__lowerCAmelCase ,   __lowerCAmelCase      )      )


if __name__ == "__main__":
 lowerCamelCase     :							Union[str, Any]    ='''0094702343221'''

 print(is_sri_lankan_phone_number(phone))