


from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor






class   __lowercase				:





      def __init__(		self						:					Any					,       __lowerCamelCase						:					Optional[Any]					,       __lowerCamelCase						:					Any=3					,       __lowerCamelCase						:					int=3_2					,       __lowerCamelCase						:					List[str]=3					,       __lowerCamelCase						:					Dict=1_0					,       __lowerCamelCase						:					List[Any]=[1_0, 2_0, 3_0, 4_0]					,       __lowerCamelCase						:					int=[1, 1, 2, 1]					,       __lowerCamelCase						:					Union[str, Any]=True					,       __lowerCamelCase						:					Optional[Any]=True					,       __lowerCamelCase						:					int="relu"					,       __lowerCamelCase						:					Dict=3					,       __lowerCamelCase						:					List[str]=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(__lowerCamelCase       )





      def        _lowercase				(		self						:					List[Any]       )    ->   Union[str, Any]:






         """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						:					Any       )    ->   Any:






         """simple docstring"""







         return RegNetConfig(
             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					,       )





      def        _lowercase				(		self						:					Dict					,       __lowerCamelCase						:					Dict					,       __lowerCamelCase						:					Dict					,       __lowerCamelCase						:					List[str]       )    ->   Union[str, Any]:






         """simple docstring"""







         UpperCAmelCase							=     TFRegNetModel(config=__lowerCamelCase       )
         UpperCAmelCase							=     model(__lowerCamelCase					,       training=__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 // 3_2, self.image_size // 3_2)					,       )





      def        _lowercase				(		self						:					str					,       __lowerCamelCase						:					Optional[Any]					,       __lowerCamelCase						:					List[str]					,       __lowerCamelCase						:					Any       )    ->   List[str]:






         """simple docstring"""







         UpperCAmelCase							=     self.num_labels
         UpperCAmelCase							=     TFRegNetForImageClassification(__lowerCamelCase       )
         UpperCAmelCase							=     model(__lowerCamelCase					,       labels=__lowerCamelCase					,       training=__lowerCamelCase       )
         self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.num_labels)       )





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






         """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   __lowercase				(  __snake_case ,					__snake_case ,					unittest.TestCase  ):
      UpperCamelCase								=       (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
      UpperCamelCase								=       (
          {'''feature-extraction''': TFRegNetModel, '''image-classification''': TFRegNetForImageClassification}
          if is_tf_available()
          else {}
      )

      UpperCamelCase								=       False
      UpperCamelCase								=       False
      UpperCamelCase								=       False
      UpperCamelCase								=       False
      UpperCamelCase								=       False





      def        _lowercase				(		self						:					Dict       )    ->   List[Any]:






         """simple docstring"""







         UpperCAmelCase							=     TFRegNetModelTester(self       )
         UpperCAmelCase							=     ConfigTester(self					,       config_class=__lowerCamelCase					,       has_text_modality=__lowerCamelCase       )





      def        _lowercase				(		self						:					Dict       )    ->   Optional[Any]:






         """simple docstring"""







         return





      @unittest.skip(reason="""RegNet does not use inputs_embeds"""       )
      def        _lowercase				(		self						:					List[str]       )    ->   Tuple:






         """simple docstring"""







         pass





      @unittest.skipIf(
          not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""       )       ) == 0					,       reason="""TF does not support backprop for grouped convolutions on CPU."""					,       )
      @slow
      def        _lowercase				(		self						:					str       )    ->   List[Any]:






         """simple docstring"""







         super().test_keras_fit()





      @unittest.skip(reason="""RegNet does not support input and output embeddings"""       )
      def        _lowercase				(		self						:					List[str]       )    ->   Tuple:






         """simple docstring"""







         pass





      def        _lowercase				(		self						:					str       )    ->   int:






         """simple docstring"""







         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase							=     model_class(__lowerCamelCase       )
            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]					,       __lowerCamelCase       )





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






         """simple docstring"""







         UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCamelCase       )





      def        _lowercase				(		self						:					Optional[Any]       )    ->   Union[str, Any]:






         """simple docstring"""







         def check_hidden_states_output(__lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					List[Any]       ):
            UpperCAmelCase							=     model_class(__lowerCamelCase       )
            UpperCAmelCase							=     model(**self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase       )					,       training=__lowerCamelCase       )

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

            UpperCAmelCase							=     self.model_tester.num_stages
            self.assertEqual(len(__lowerCamelCase       )					,       expected_num_stages + 1       )

            # RegNet'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 // 2, self.model_tester.image_size // 2]					,       )

         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(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase       )

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

               check_hidden_states_output(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase       )





      def        _lowercase				(		self						:					Union[str, Any]       )    ->   Dict:






         """simple docstring"""







         UpperCAmelCase				,  UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs_for_common()

         def check_equivalence(__lowerCamelCase						:					List[Any]					,       __lowerCamelCase						:					Dict					,       __lowerCamelCase						:					List[Any]					,       __lowerCamelCase						:					List[str]={}       ):
            UpperCAmelCase							=     model(__lowerCamelCase					,       return_dict=__lowerCamelCase					,       **__lowerCamelCase       )
            UpperCAmelCase							=     model(__lowerCamelCase					,       return_dict=__lowerCamelCase					,       **__lowerCamelCase       ).to_tuple()

            def recursive_check(__lowerCamelCase						:					List[Any]					,       __lowerCamelCase						:					Dict       ):
               if isinstance(__lowerCamelCase					,       (List, Tuple)       ):
                  for tuple_iterable_value, dict_iterable_value in zip(__lowerCamelCase					,       __lowerCamelCase       ):
                     recursive_check(__lowerCamelCase					,       __lowerCamelCase       )
               elif tuple_object is None:
                  return
               else:
                  self.assertTrue(
                      all(tf.equal(__lowerCamelCase					,       __lowerCamelCase       )       )					,       msg=(
                          """Tuple and dict output are not equal. Difference:"""
                          F""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object       )       )}"""
                      )					,       )

               recursive_check(__lowerCamelCase					,       __lowerCamelCase       )

         for model_class in self.all_model_classes:
            UpperCAmelCase							=     model_class(__lowerCamelCase       )

            UpperCAmelCase							=     self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase       )
            UpperCAmelCase							=     self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase       )
            check_equivalence(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase       )

            UpperCAmelCase							=     self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase					,       return_labels=__lowerCamelCase       )
            UpperCAmelCase							=     self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase					,       return_labels=__lowerCamelCase       )
            check_equivalence(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase       )

            UpperCAmelCase							=     self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase       )
            UpperCAmelCase							=     self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase       )
            check_equivalence(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       {"""output_hidden_states""": True}       )

            UpperCAmelCase							=     self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase					,       return_labels=__lowerCamelCase       )
            UpperCAmelCase							=     self._prepare_for_class(__lowerCamelCase					,       __lowerCamelCase					,       return_labels=__lowerCamelCase       )
            check_equivalence(__lowerCamelCase					,       __lowerCamelCase					,       __lowerCamelCase					,       {"""output_hidden_states""": True}       )





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






         """simple docstring"""







         UpperCAmelCase							=     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase       )





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






         """simple docstring"""







         for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase							=     TFRegNetModel.from_pretrained(__lowerCamelCase       )
            self.assertIsNotNone(__lowerCamelCase       )

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







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





      @cached_property
      def        _lowercase				(		self						:					str       )    ->   Tuple:






         """simple docstring"""







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





      @slow
      def        _lowercase				(		self						:					Optional[Any]       )    ->   Any:






         """simple docstring"""







         UpperCAmelCase							=     TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

         UpperCAmelCase							=     self.default_image_processor
         UpperCAmelCase							=     prepare_img()
         UpperCAmelCase							=     image_processor(images=__lowerCamelCase					,       return_tensors="""tf"""       )

         # forward pass
         UpperCAmelCase							=     model(**__lowerCamelCase					,       training=__lowerCamelCase       )

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

         UpperCAmelCase							=     tf.constant([-0.4_180, -1.5_051, -3.4_836]       )

         tf.debugging.assert_near(outputs.logits[0, :3]					,       __lowerCamelCase					,       atol=1e-4       )







from __future__ import annotations
def   _UpperCamelCase				(						lowerCAmelCase_   )						->None:
   create_state_space_tree(lowerCAmelCase_  ,						[]  ,						0  ,						[0 for i in range(len(lowerCAmelCase_   )   )]   )
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						)						->None:

   if index == len(lowerCAmelCase_   ):
      print(lowerCAmelCase_   )
      return

   for i in range(len(lowerCAmelCase_   )   ):
      if not index_used[i]:
         current_sequence.append(sequence[i]   )
         UpperCAmelCase							=     True
         create_state_space_tree(lowerCAmelCase_  ,						lowerCAmelCase_  ,						index + 1  ,						lowerCAmelCase_   )
         current_sequence.pop()
         UpperCAmelCase							=     False
__a     =			[3, 1, 2, 4]
generate_all_permutations(sequence)

__a     =			["A", "B", "C"]







generate_all_permutations(sequence_a)



