"""simple docstring"""




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 					A							:


   def __init__(self					:						Union[str, Any]	,  __UpperCAmelCase					:						Union[str, Any]	,  __UpperCAmelCase					:						int=3	,  __UpperCAmelCase					:						Optional[Any]=3_2	,  __UpperCAmelCase					:						List[str]=3	,  __UpperCAmelCase					:						int=1_0	,  __UpperCAmelCase					:						str=[1_0, 2_0, 3_0, 4_0]	,  __UpperCAmelCase					:						Union[str, Any]=[1, 1, 2, 1]	,  __UpperCAmelCase					:						Optional[Any]=True	,  __UpperCAmelCase					:						Optional[Any]=True	,  __UpperCAmelCase					:						int="relu"	,  __UpperCAmelCase					:						int=3	,  __UpperCAmelCase					:						Optional[int]=None	,  )						->    int:
         """simple docstring"""



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


   def       lowercase_				(self					:						List[str]		)						->    Tuple:
         """simple docstring"""



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

         UpperCAmelCase__								=  None
         if self.use_labels:
               UpperCAmelCase__								=  ids_tensor([self.batch_size]	,  self.num_labels		)

         UpperCAmelCase__								=  self.get_config()

         return config, pixel_values, labels


   def       lowercase_				(self					:						Union[str, Any]		)						->    Tuple:
         """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       lowercase_				(self					:						Dict	,  __UpperCAmelCase					:						Optional[Any]	,  __UpperCAmelCase					:						Dict	,  __UpperCAmelCase					:						int		)						->    Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  TFResNetModel(config=__UpperCAmelCase		)
         UpperCAmelCase__								=  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 // 3_2, self.image_size // 3_2)	,  )


   def       lowercase_				(self					:						str	,  __UpperCAmelCase					:						Optional[Any]	,  __UpperCAmelCase					:						List[str]	,  __UpperCAmelCase					:						Optional[int]		)						->    List[Any]:
         """simple docstring"""



         UpperCAmelCase__								=  self.num_labels
         UpperCAmelCase__								=  TFResNetForImageClassification(__UpperCAmelCase		)
         UpperCAmelCase__								=  model(__UpperCAmelCase	,  labels=__UpperCAmelCase		)
         self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.num_labels)		)





   def       lowercase_				(self					:						Tuple		)						->    Any:
         """simple docstring"""



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





@require_tf
class 					A							(    UpperCAmelCase_		,    UpperCAmelCase_		,    unittest.TestCase					):
   __UpperCAmelCase			:			Optional[int]              =      (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
   __UpperCAmelCase			:			Tuple              =      (
       {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
       if is_tf_available()
       else {}
   )

   __UpperCAmelCase			:			List[Any]              =      False
   __UpperCAmelCase			:			int              =      False
   __UpperCAmelCase			:			Optional[Any]              =      False
   __UpperCAmelCase			:			Optional[int]              =      False
   __UpperCAmelCase			:			List[str]              =      False


   def       lowercase_				(self					:						Tuple		)						->    List[Any]:
         """simple docstring"""



         UpperCAmelCase__								=  TFResNetModelTester(self		)
         UpperCAmelCase__								=  ConfigTester(self	,  config_class=__UpperCAmelCase	,  has_text_modality=__UpperCAmelCase		)


   def       lowercase_				(self					:						List[Any]		)						->    str:
         """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					:						List[str]		)						->    Dict:
         """simple docstring"""



         return


   @unittest.skip(reason="ResNet does not use inputs_embeds"		)
   def       lowercase_				(self					:						str		)						->    Union[str, Any]:
         """simple docstring"""



         pass


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



         pass


   def       lowercase_				(self					:						List[Any]		)						->    Optional[Any]:
         """simple docstring"""



         UpperCAmelCase__		,				UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs_for_common()

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

               UpperCAmelCase__								=  ["pixel_values"]
               self.assertListEqual(arg_names[:1]	,  __UpperCAmelCase		)


   def       lowercase_				(self					:						Union[str, Any]		)						->    Optional[Any]:
         """simple docstring"""



         UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__UpperCAmelCase		)


   def       lowercase_				(self					:						Optional[Any]		)						->    int:
         """simple docstring"""



         def check_hidden_states_output(__UpperCAmelCase					:						Union[str, Any]	,  __UpperCAmelCase					:						List[str]	,  __UpperCAmelCase					:						int		):
               UpperCAmelCase__								=  model_class(__UpperCAmelCase		)
               UpperCAmelCase__								=  model(**self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase		)		)

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

               UpperCAmelCase__								=  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]	,  )

         UpperCAmelCase__		,				UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs_for_common()
         UpperCAmelCase__								=  ["basic", "bottleneck"]
         for model_class in self.all_model_classes:
               for layer_type in layers_type:
                     UpperCAmelCase__								=  layer_type
                     UpperCAmelCase__								=  True
                     check_hidden_states_output(__UpperCAmelCase	,  __UpperCAmelCase	,  __UpperCAmelCase		)

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

                     check_hidden_states_output(__UpperCAmelCase	,  __UpperCAmelCase	,  __UpperCAmelCase		)


   def       lowercase_				(self					:						Tuple		)						->    int:
         """simple docstring"""



         UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase		)





   @slow
   def       lowercase_				(self					:						Optional[int]		)						->    List[Any]:
         """simple docstring"""



         for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               UpperCAmelCase__								=  TFResNetModel.from_pretrained(__UpperCAmelCase		)
               self.assertIsNotNone(__UpperCAmelCase		)




def        lowerCAmelCase_			(					)					->    Union[str, Any]:







      '''simple docstring'''


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







@require_tf
@require_vision
class 					A							(    unittest.TestCase					):


   @cached_property
   def       lowercase_				(self					:						Dict		)						->    Union[str, Any]:
         """simple docstring"""



         return (
             AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)
             if is_vision_available()
             else None
         )





   @slow
   def       lowercase_				(self					:						Tuple		)						->    str:
         """simple docstring"""



         UpperCAmelCase__								=  TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)

         UpperCAmelCase__								=  self.default_image_processor
         UpperCAmelCase__								=  prepare_img()
         UpperCAmelCase__								=  image_processor(images=__UpperCAmelCase	,  return_tensors="tf"		)

         # forward pass
         UpperCAmelCase__								=  model(**__UpperCAmelCase		)

         # verify the logits
         UpperCAmelCase__								=  tf.TensorShape((1, 1_0_0_0)		)
         self.assertEqual(outputs.logits.shape	,  __UpperCAmelCase		)

         UpperCAmelCase__								=  tf.constant([-11.1069, -9.7877, -8.3777]		)

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




from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
      if not (is_transformers_available() and is_torch_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from ...utils.dummy_torch_and_transformers_objects import ShapEPipeline
else:
      from .camera import create_pan_cameras
      from .pipeline_shap_e import ShapEPipeline
      from .pipeline_shap_e_img2img import ShapEImgaImgPipeline
      from .renderer import (
          BoundingBoxVolume,
          ImportanceRaySampler,
          MLPNeRFModelOutput,
          MLPNeRSTFModel,
          ShapEParamsProjModel,
          ShapERenderer,
          StratifiedRaySampler,
          VoidNeRFModel,
      )



