

import inspect
import unittest

from transformers import EfficientNetConfig
from transformers.testing_utils import is_pipeline_test, 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 EfficientNetForImageClassification, EfficientNetModel
    from transformers.models.efficientnet.modeling_efficientnet import EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor







class 					__lowerCamelCase							:







      def __init__(	self				,    lowerCamelCase				,    lowerCamelCase=13				,    lowerCamelCase=32				,    lowerCamelCase=3				,    lowerCamelCase=[3, 3, 5]				,    lowerCamelCase=[32, 16, 24]				,    lowerCamelCase=[16, 24, 40]				,    lowerCamelCase=[1, 1, 2]				,    lowerCamelCase=[1, 1, 2]				,    lowerCamelCase=[1, 6, 6]				,    lowerCamelCase=True				,    lowerCamelCase=True				,    lowerCamelCase=37				,    lowerCamelCase="gelu"				,    lowerCamelCase=10				,    )		->			Union[str, Any]:
        snake_case_					= parent
        snake_case_					= batch_size
        snake_case_					= image_size
        snake_case_					= num_channels
        snake_case_					= kernel_sizes
        snake_case_					= in_channels
        snake_case_					= out_channels
        snake_case_					= strides
        snake_case_					= num_block_repeats
        snake_case_					= expand_ratios
        snake_case_					= is_training
        snake_case_					= hidden_act
        snake_case_					= num_labels
        snake_case_					= use_labels







      def       lowerCAmelCase_       (	self  )		->			Tuple:
        snake_case_					= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

        snake_case_					= self.get_config()
        return config, pixel_values, labels







      def       lowerCAmelCase_       (	self  )		->			Optional[Any]:
        return EfficientNetConfig(
            num_channels=self.num_channels				,    kernel_sizes=self.kernel_sizes				,    in_channels=self.in_channels				,    out_channels=self.out_channels				,    strides=self.strides				,    num_block_repeats=self.num_block_repeats				,    expand_ratios=self.expand_ratios				,    hidden_act=self.hidden_act				,    num_labels=self.num_labels				,    )







      def       lowerCAmelCase_       (	self				,    lowerCamelCase				,    lowerCamelCase				,    lowerCamelCase  )		->			Any:
        snake_case_					= EfficientNetModel(config=lowerCamelCase  )
        model.to(lowerCamelCase  )
        model.eval()
        snake_case_					= model(lowerCamelCase  )
        # expected last hidden states: B, C, H // 4, W // 4
        self.parent.assertEqual(
            result.last_hidden_state.shape				,    (self.batch_size, config.hidden_dim, self.image_size // 4, self.image_size // 4)				,    )







      def       lowerCAmelCase_       (	self				,    lowerCamelCase				,    lowerCamelCase				,    lowerCamelCase  )		->			Optional[Any]:
        snake_case_					= EfficientNetForImageClassification(lowerCamelCase  )
        model.to(lowerCamelCase  )
        model.eval()
        snake_case_					= model(lowerCamelCase				,    labels=lowerCamelCase  )
        self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_labels)  )







      def       lowerCAmelCase_       (	self  )		->			str:
        snake_case_					= self.prepare_config_and_inputs()
        snake_case_		,							snake_case_		,							snake_case_					= config_and_inputs
        snake_case_					= {"""pixel_values""": pixel_values}
        return config, inputs_dict







@require_torch
class 					__lowerCamelCase							(      __snake_case    ,				__snake_case    ,				unittest.TestCase      ):
      lowerCamelCase_      : Tuple  			=   (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
      lowerCamelCase_      : Union[str, Any]  			=   (
          {'feature-extraction': EfficientNetModel, 'image-classification': EfficientNetForImageClassification}
          if is_torch_available()
          else {}
      )

      lowerCamelCase_      : Optional[Any]  			=   False
      lowerCamelCase_      : Optional[Any]  			=   False
      lowerCamelCase_      : Any  			=   False
      lowerCamelCase_      : Tuple  			=   False
      lowerCamelCase_      : List[str]  			=   False







      def       lowerCAmelCase_       (	self  )		->			int:
        snake_case_					= EfficientNetModelTester(self  )
        snake_case_					= ConfigTester(
            self				,    config_class=lowerCamelCase				,    has_text_modality=lowerCamelCase				,    hidden_size=37  )







      def       lowerCAmelCase_       (	self  )		->			Dict:
        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  )		->			Dict:
        return







      @unittest.skip(reason="""EfficientNet does not use inputs_embeds"""  )
      def       lowerCAmelCase_       (	self  )		->			Tuple:
        pass







      @unittest.skip(reason="""EfficientNet does not support input and output embeddings"""  )
      def       lowerCAmelCase_       (	self  )		->			Optional[int]:
        pass







      @unittest.skip(reason="""EfficientNet does not use feedforward chunking"""  )
      def       lowerCAmelCase_       (	self  )		->			str:
        pass







      def       lowerCAmelCase_       (	self  )		->			Tuple:
        snake_case_		,							snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()

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

          snake_case_					= ["""pixel_values"""]
          self.assertListEqual(arg_names[:1]				,    lowerCamelCase  )







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        snake_case_					= self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCamelCase  )







      def       lowerCAmelCase_       (	self  )		->			Any:
        def check_hidden_states_output(lowerCamelCase				,    lowerCamelCase				,    lowerCamelCase  ):
          snake_case_					= model_class(lowerCamelCase  )
          model.to(lowerCamelCase  )
          model.eval()

          with torch.no_grad():
            snake_case_					= model(**self._prepare_for_class(lowerCamelCase				,    lowerCamelCase  )  )

          snake_case_					= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
          snake_case_					= sum(config.num_block_repeats  ) * 4
          self.assertEqual(len(lowerCamelCase  )				,    lowerCamelCase  )

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

        snake_case_		,							snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          snake_case_					= True
          check_hidden_states_output(lowerCamelCase				,    lowerCamelCase				,    lowerCamelCase  )

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

          check_hidden_states_output(lowerCamelCase				,    lowerCamelCase				,    lowerCamelCase  )







      def       lowerCAmelCase_       (	self  )		->			str:
        snake_case_					= self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*lowerCamelCase  )







      @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""  )
      def       lowerCAmelCase_       (	self  )		->			int:
        pass







      @slow
      def       lowerCAmelCase_       (	self  )		->			Optional[int]:
        for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          snake_case_					= EfficientNetModel.from_pretrained(lowerCamelCase  )
          self.assertIsNotNone(lowerCamelCase  )







      @is_pipeline_test
      @require_vision
      @slow
      def       lowerCAmelCase_       (	self  )		->			Any:
        super().test_pipeline_image_classification()



def   UpperCamelCase(   )      ->							Optional[Any]:





  '''simple docstring'''





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







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







      @cached_property
      def       lowerCAmelCase_       (	self  )		->			Tuple:
        return AutoImageProcessor.from_pretrained("""google/efficientnet-b7"""  ) if is_vision_available() else None







      @slow
      def       lowerCAmelCase_       (	self  )		->			List[str]:
        snake_case_					= EfficientNetForImageClassification.from_pretrained("""google/efficientnet-b7"""  ).to(lowerCamelCase  )

        snake_case_					= self.default_image_processor
        snake_case_					= prepare_img()
        snake_case_					= image_processor(images=lowerCamelCase				,    return_tensors="""pt"""  ).to(lowerCamelCase  )

        # forward pass
        with torch.no_grad():
          snake_case_					= model(**lowerCamelCase  )

        # verify the logits
        snake_case_					= torch.Size((1, 1000)  )
        self.assertEqual(outputs.logits.shape				,    lowerCamelCase  )

        snake_case_					= torch.tensor([0.0001, 0.0002, 0.0002]  ).to(lowerCamelCase  )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]				,    lowerCamelCase				,    atol=1e-4  )  )


import unittest

from diffusers import __version__
from diffusers.utils import deprecate







class 					__lowerCamelCase							(      unittest.TestCase      ):
      lowerCamelCase_      : Dict  			=   '.'.join([str(int(__version__.split('.'      )[0]      ) + 1      )] + __version__.split('.'      )[1:]      )
      lowerCamelCase_      : int  			=   '0.0.1'







      def       lowerCAmelCase_       (	self  )		->			Optional[int]:
        snake_case_					= {"""deprecated_arg""": 4}

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate("""deprecated_arg"""				,    self.higher_version				,    """message"""				,    take_from=lowerCamelCase  )

        assert output == 4
        assert (
            str(warning.warning  )
            == f'''The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}.'''
            " message"
        )







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        snake_case_					= {"""deprecated_arg""": 4}

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate(("""deprecated_arg""", self.higher_version, """message""")				,    take_from=lowerCamelCase  )

        assert output == 4
        assert (
            str(warning.warning  )
            == f'''The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}.'''
            " message"
        )







      def       lowerCAmelCase_       (	self  )		->			int:
        snake_case_					= {"""deprecated_arg_1""": 4, """deprecated_arg_2""": 8}
        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_		,							snake_case_					= deprecate(
              ("""deprecated_arg_1""", self.higher_version, """Hey""")				,    ("""deprecated_arg_2""", self.higher_version, """Hey""")				,    take_from=lowerCamelCase				,    )
        assert output_a == 4
        assert output_a == 8
        assert (
            str(warning.warnings[0].message  )
            == "The `deprecated_arg_1` argument is deprecated and will be removed in version"
            f''' {self.higher_version}. Hey'''
        )
        assert (
            str(warning.warnings[1].message  )
            == "The `deprecated_arg_2` argument is deprecated and will be removed in version"
            f''' {self.higher_version}. Hey'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:
        snake_case_					= {"""deprecated_arg""": 4}

        with self.assertRaises(lowerCamelCase  ) as error:
          deprecate(("""wrong_arg""", self.higher_version, """message""")				,    take_from=lowerCamelCase  )

        assert "test_deprecate_function_incorrect_arg in" in str(error.exception  )
        assert "line" in str(error.exception  )
        assert "got an unexpected keyword argument `deprecated_arg`" in str(error.exception  )







      def       lowerCAmelCase_       (	self  )		->			Optional[Any]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """message""")  )

        assert (
            str(warning.warning  )
            == f'''`deprecated_arg` is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(
              ("""deprecated_arg_1""", self.higher_version, """Hey""")				,    ("""deprecated_arg_2""", self.higher_version, """Hey""")				,    )
        assert (
            str(warning.warnings[0].message  )
            == f'''`deprecated_arg_1` is deprecated and will be removed in version {self.higher_version}. Hey'''
        )
        assert (
            str(warning.warnings[1].message  )
            == f'''`deprecated_arg_2` is deprecated and will be removed in version {self.higher_version}. Hey'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:







        class 					__lowerCamelCase							:
              lowerCamelCase_      : Dict  			=   5

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate(("""arg""", self.higher_version, """message""")				,    take_from=Args()  )

        assert arg == 5
        assert (
            str(warning.warning  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:







        class 					__lowerCamelCase							:
              lowerCamelCase_      : str  			=   5
              lowerCamelCase_      : List[str]  			=   7

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_		,							snake_case_					= deprecate(
              ("""arg""", self.higher_version, """message""")				,    ("""foo""", self.higher_version, """message""")				,    ("""does not exist""", self.higher_version, """message""")				,    take_from=Args()				,    )

        assert arg_a == 5
        assert arg_a == 7
        assert (
            str(warning.warning  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )
        assert (
            str(warning.warnings[0].message  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )
        assert (
            str(warning.warnings[1].message  )
            == f'''The `foo` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			int:
        snake_case_					= {"""deprecated_arg""": 4}

        with self.assertRaises(lowerCamelCase  ) as error:
          deprecate(("""wrong_arg""", self.lower_version, """message""")				,    take_from=lowerCamelCase  )

        assert (
            str(error.exception  )
            == "The deprecation tuple ('wrong_arg', '0.0.1', 'message') should be removed since diffusers' version"
            f''' {__version__} is >= {self.lower_version}'''
        )







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """This message is better!!!""")				,    standard_warn=lowerCamelCase  )

        assert str(warning.warning  ) == "This message is better!!!"







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """This message is better!!!""")				,    standard_warn=lowerCamelCase  )
        assert str(warning.warning  ) == "This message is better!!!"
        assert "diffusers/tests/others/test_utils.py" in warning.filename