





import inspect
import unittest

from transformers import ResNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
      import jax
      import jax.numpy as jnp

      from transformers.models.resnet.modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel

if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor

class 						UpperCamelCase__					( unittest.TestCase  ):



     '''simple docstring'''

     def __init__(				self		:       List[Any]		,lowerCamelCase__		:       Optional[Any]		,lowerCamelCase__		:       List[str]=3		,lowerCamelCase__		:       Union[str, Any]=32		,lowerCamelCase__		:       Tuple=3		,lowerCamelCase__		:       int=10		,lowerCamelCase__		:       int=[10, 20, 30, 40]		,lowerCamelCase__		:       List[Any]=[1, 1, 2, 1]		,lowerCamelCase__		:       Optional[int]=True		,lowerCamelCase__		:       int=True		,lowerCamelCase__		:       Any="relu"		,lowerCamelCase__		:       Optional[int]=3		,lowerCamelCase__		:       List[Any]=None		,)	->						List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		parent
           SCREAMING_SNAKE_CASE						=		batch_size
           SCREAMING_SNAKE_CASE						=		image_size
           SCREAMING_SNAKE_CASE						=		num_channels
           SCREAMING_SNAKE_CASE						=		embeddings_size
           SCREAMING_SNAKE_CASE						=		hidden_sizes
           SCREAMING_SNAKE_CASE						=		depths
           SCREAMING_SNAKE_CASE						=		is_training
           SCREAMING_SNAKE_CASE						=		use_labels
           SCREAMING_SNAKE_CASE						=		hidden_act
           SCREAMING_SNAKE_CASE						=		num_labels
           SCREAMING_SNAKE_CASE						=		scope
           SCREAMING_SNAKE_CASE						=		len(lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Union[str, Any]			)	->						int:




           '''simple docstring'''


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

           SCREAMING_SNAKE_CASE						=		self.get_config()

           return config, pixel_values






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						str:




           '''simple docstring'''


           return ResNetConfig(
               num_channels=self.num_channels		,embeddings_size=self.embeddings_size		,hidden_sizes=self.hidden_sizes		,depths=self.depths		,hidden_act=self.hidden_act		,num_labels=self.num_labels		,image_size=self.image_size		,)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[int]		,lowerCamelCase__		:       Tuple		,lowerCamelCase__		:       Optional[int]			)	->						List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		FlaxResNetModel(config=lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		model(lowerCamelCase__			)

           # Output shape (b, c, h, w)
           self.parent.assertEqual(
               result.last_hidden_state.shape		,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)		,)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any		,lowerCamelCase__		:       int		,lowerCamelCase__		:       int			)	->						Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.num_labels
           SCREAMING_SNAKE_CASE						=		FlaxResNetForImageClassification(config=lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		model(lowerCamelCase__			)
           self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_labels)			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[int]			)	->						Tuple:




           '''simple docstring'''


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

@require_flax
class 						UpperCamelCase__					( lowerCAmelCase_				, unittest.TestCase  ):



     '''simple docstring'''

     __snake_case       :      Tuple						      =     (FlaxResNetModel, FlaxResNetForImageClassification) if is_flax_available() else ()

     __snake_case       :      Union[str, Any]						      =     False
     __snake_case       :      Optional[Any]						      =     False
     __snake_case       :      Any						      =     False






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						None:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		FlaxResNetModelTester(self			)
           SCREAMING_SNAKE_CASE						=		ConfigTester(self		,config_class=lowerCamelCase__		,has_text_modality=lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						Union[str, 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 							SCREAMING_SNAKE_CASE__    (				self		:       Tuple			)	->						List[Any]:




           '''simple docstring'''


           return






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__			)






     @unittest.skip(reason="""ResNet does not use inputs_embeds"""			)
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						Any:




           '''simple docstring'''


           pass






     @unittest.skip(reason="""ResNet does not support input and output embeddings"""			)
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Union[str, Any]			)	->						Tuple:




           '''simple docstring'''


           pass






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs_for_common()

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

                 SCREAMING_SNAKE_CASE						=		["""pixel_values"""]
                 self.assertListEqual(arg_names[:1]		,lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       int			)	->						List[Any]:




           '''simple docstring'''


           def check_hidden_states_output(lowerCamelCase__		:       List[str]		,lowerCamelCase__		:       Optional[Any]		,lowerCamelCase__		:       str			):
                 SCREAMING_SNAKE_CASE						=		model_class(lowerCamelCase__			)

                 SCREAMING_SNAKE_CASE						=		model(**self._prepare_for_class(lowerCamelCase__		,lowerCamelCase__			)			)

                 SCREAMING_SNAKE_CASE						=		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                 SCREAMING_SNAKE_CASE						=		self.model_tester.num_stages
                 self.assertEqual(len(lowerCamelCase__			)		,expected_num_stages + 1			)






     @unittest.skip(reason="""ResNet does not use feedforward chunking"""			)
     def 							SCREAMING_SNAKE_CASE__    (				self		:       int			)	->						int:




           '''simple docstring'''


           pass






     def 							SCREAMING_SNAKE_CASE__    (				self		:       str			)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__			):
                       SCREAMING_SNAKE_CASE						=		self._prepare_for_class(lowerCamelCase__		,lowerCamelCase__			)
                       SCREAMING_SNAKE_CASE						=		model_class(lowerCamelCase__			)

                       @jax.jit
                       def model_jitted(lowerCamelCase__		:       List[str]		,**lowerCamelCase__		:       List[str]			):
                             return model(pixel_values=lowerCamelCase__		,**lowerCamelCase__			)

                       with self.subTest("""JIT Enabled"""			):
                             SCREAMING_SNAKE_CASE						=		model_jitted(**lowerCamelCase__			).to_tuple()

                       with self.subTest("""JIT Disabled"""			):
                             with jax.disable_jit():
                                   SCREAMING_SNAKE_CASE						=		model_jitted(**lowerCamelCase__			).to_tuple()

                       self.assertEqual(len(lowerCamelCase__			)		,len(lowerCamelCase__			)			)
                       for jitted_output, output in zip(lowerCamelCase__		,lowerCamelCase__			):
                             self.assertEqual(jitted_output.shape		,output.shape			)



def   __lowercase  ( )					->  List[str]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE						=		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""      )
      return image



@require_flax
class 						UpperCamelCase__					( unittest.TestCase  ):



     '''simple docstring'''

     @cached_property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						List[str]:




           '''simple docstring'''


           return AutoImageProcessor.from_pretrained("""microsoft/resnet-50"""			) if is_vision_available() else None






     @slow
     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		FlaxResNetForImageClassification.from_pretrained("""microsoft/resnet-50"""			)

           SCREAMING_SNAKE_CASE						=		self.default_image_processor
           SCREAMING_SNAKE_CASE						=		prepare_img()
           SCREAMING_SNAKE_CASE						=		image_processor(images=lowerCamelCase__		,return_tensors="""np"""			)

           SCREAMING_SNAKE_CASE						=		model(**lowerCamelCase__			)

           # verify the logits
           SCREAMING_SNAKE_CASE						=		(1, 1000)
           self.assertEqual(outputs.logits.shape		,lowerCamelCase__			)

           SCREAMING_SNAKE_CASE						=		jnp.array([-11.1069, -9.7877, -8.3777]			)

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









from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


SCREAMING_SNAKE_CASE_		  =			{
    """configuration_markuplm""": ["""MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MarkupLMConfig"""],
    """feature_extraction_markuplm""": ["""MarkupLMFeatureExtractor"""],
    """processing_markuplm""": ["""MarkupLMProcessor"""],
    """tokenization_markuplm""": ["""MarkupLMTokenizer"""],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE_		  =			["""MarkupLMTokenizerFast"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE_		  =			[
          """MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """MarkupLMForQuestionAnswering""",
          """MarkupLMForSequenceClassification""",
          """MarkupLMForTokenClassification""",
          """MarkupLMModel""",
          """MarkupLMPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_markuplm import MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP, MarkupLMConfig
      from .feature_extraction_markuplm import MarkupLMFeatureExtractor
      from .processing_markuplm import MarkupLMProcessor
      from .tokenization_markuplm import MarkupLMTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_markuplm_fast import MarkupLMTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_markuplm import (
                MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST,
                MarkupLMForQuestionAnswering,
                MarkupLMForSequenceClassification,
                MarkupLMForTokenClassification,
                MarkupLMModel,
                MarkupLMPreTrainedModel,
            )


else:
      import sys

      SCREAMING_SNAKE_CASE_		  =			_LazyModule(__name__, globals()["""__file__"""], _import_structure)


