from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import TFResNetForImageClassification, TFResNetModel
      from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor

class    _UpperCAmelCase							:
      def __init__(		self      ,       a__      ,       a__=3      ,       a__=32      ,       a__=3      ,       a__=10      ,       a__=[10, 20, 30, 40]      ,       a__=[1, 1, 2, 1]      ,       a__=True      ,       a__=True      ,       a__="relu"      ,       a__=3      ,       a__=None      ,       ):
         A_     :				List[Any]			      =	parent
         A_     :				Union[str, Any]			      =	batch_size
         A_     :				Union[str, Any]			      =	image_size
         A_     :				Optional[int]			      =	num_channels
         A_     :				str			      =	embeddings_size
         A_     :				Optional[Any]			      =	hidden_sizes
         A_     :				List[str]			      =	depths
         A_     :				List[str]			      =	is_training
         A_     :				Union[str, Any]			      =	use_labels
         A_     :				str			      =	hidden_act
         A_     :				Dict			      =	num_labels
         A_     :				str			      =	scope
         A_     :				Any			      =	len(UpperCamelCase_       )
      def 		_lowerCamelCase      (		self       ):
         A_     :				List[str]			      =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

         A_     :				Any			      =	self.get_config()

         return config, pixel_values, labels
      def 		_lowerCamelCase      (		self       ):
         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 		_lowerCamelCase      (		self      ,       a__      ,       a__      ,       a__       ):
         A_     :				Optional[int]			      =	TFResNetModel(config=UpperCamelCase_       )
         A_     :				Tuple			      =	model(UpperCamelCase_       )
         # 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 		_lowerCamelCase      (		self      ,       a__      ,       a__      ,       a__       ):
         A_     :				Any			      =	self.num_labels
         A_     :				Tuple			      =	TFResNetForImageClassification(UpperCamelCase_       )
         A_     :				Optional[Any]			      =	model(UpperCamelCase_      ,       labels=UpperCamelCase_       )
         self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_labels)       )






      def 		_lowerCamelCase      (		self       ):
         A_     :				Optional[Any]			      =	self.prepare_config_and_inputs()
         A_     :				Any			      =	config_and_inputs
         A_     :				List[str]			      =	{'pixel_values': pixel_values}
         return config, inputs_dict






@require_tf
class    _UpperCAmelCase							(		_lowerCamelCase			,       _lowerCamelCase			,       unittest.TestCase     ):
      a						       =							(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
      a						       =							(
          {'''feature-extraction''': TFResNetModel, '''image-classification''': TFResNetForImageClassification}
          if is_tf_available()
          else {}
      )

      a						       =							False
      a						       =							False
      a						       =							False
      a						       =							False
      a						       =							False
      def 		_lowerCamelCase      (		self       ):
         A_     :				Any			      =	TFResNetModelTester(self       )
         A_     :				Any			      =	ConfigTester(self      ,       config_class=UpperCamelCase_      ,       has_text_modality=UpperCamelCase_       )
      def 		_lowerCamelCase      (		self       ):
         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 		_lowerCamelCase      (		self       ):
         return
      @unittest.skip(reason="""ResNet does not use inputs_embeds"""       )
      def 		_lowerCamelCase      (		self       ):
         pass
      @unittest.skip(reason="""ResNet does not support input and output embeddings"""       )
      def 		_lowerCamelCase      (		self       ):
         pass
      def 		_lowerCamelCase      (		self       ):
         A_     :				Any			      =	self.model_tester.prepare_config_and_inputs_for_common()

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

            A_     :				int			      =	['pixel_values']
            self.assertListEqual(arg_names[:1]      ,       UpperCamelCase_       )
      def 		_lowerCamelCase      (		self       ):
         A_     :				List[str]			      =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase_       )
      def 		_lowerCamelCase      (		self       ):





         def check_hidden_states_output(a__      ,       a__      ,       a__       ):
            A_     :				Union[str, Any]			      =	model_class(UpperCamelCase_       )
            A_     :				Any			      =	model(**self._prepare_for_class(UpperCamelCase_      ,       UpperCamelCase_       )       )

            A_     :				List[Any]			      =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

            A_     :				Dict			      =	self.model_tester.num_stages
            self.assertEqual(len(UpperCamelCase_       )      ,       expected_num_stages + 1       )

            # ResNet'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]      ,       )

         A_     :				Any			      =	self.model_tester.prepare_config_and_inputs_for_common()
         A_     :				Tuple			      =	['basic', 'bottleneck']
         for model_class in self.all_model_classes:
            for layer_type in layers_type:
               A_     :				Optional[Any]			      =	layer_type
               A_     :				Dict			      =	True
               check_hidden_states_output(UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_       )

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

               check_hidden_states_output(UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_       )
      def 		_lowerCamelCase      (		self       ):
         A_     :				Tuple			      =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_       )






      @slow
      def 		_lowerCamelCase      (		self       ):





         for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            A_     :				List[Any]			      =	TFResNetModel.from_pretrained(UpperCamelCase_       )
            self.assertIsNotNone(UpperCamelCase_       )






def     _lowerCAmelCase		(  ):
   '''simple docstring'''


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







@require_tf
@require_vision
class    _UpperCAmelCase							(		unittest.TestCase     ):
      @cached_property
      def 		_lowerCamelCase      (		self       ):
         return (
             AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )
             if is_vision_available()
             else None
         )






      @slow
      def 		_lowerCamelCase      (		self       ):
         A_     :				Dict			      =	TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

         A_     :				Any			      =	self.default_image_processor
         A_     :				Tuple			      =	prepare_img()
         A_     :				str			      =	image_processor(images=UpperCamelCase_      ,       return_tensors="""tf"""       )

         # forward pass
         A_     :				Optional[Any]			      =	model(**UpperCamelCase_       )

         # verify the logits
         A_     :				Tuple			      =	tf.TensorShape((1, 1000)       )
         self.assertEqual(outputs.logits.shape      ,       UpperCamelCase_       )

         A_     :				List[str]			      =	tf.constant([-11.1069, -9.7877, -8.3777]       )

         self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()      ,       UpperCamelCase_      ,       atol=1E-4       )       )













from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowerCAmelCase 				=     {
    """configuration_nllb_moe""": [
        """NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """NllbMoeConfig""",
    ]
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _lowerCAmelCase 				=     [
          """NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """NllbMoeForConditionalGeneration""",
          """NllbMoeModel""",
          """NllbMoePreTrainedModel""",
          """NllbMoeTop2Router""",
          """NllbMoeSparseMLP""",
      ]


if TYPE_CHECKING:
      from .configuration_nllb_moe import (
          NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP,
          NllbMoeConfig,
      )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_nllb_moe import (
                NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST,
                NllbMoeForConditionalGeneration,
                NllbMoeModel,
                NllbMoePreTrainedModel,
                NllbMoeSparseMLP,
                NllbMoeTopaRouter,
            )


else:
      import sys

      _lowerCAmelCase 				=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






