




"""simple docstring"""



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




    def __init__(					self		: List[str]			,				snake_case_		: int			,				snake_case_		: Dict=13			,				snake_case_		: Tuple=32			,				snake_case_		: Union[str, Any]=3			,				snake_case_		: List[str]=[3, 3, 5]			,				snake_case_		: Tuple=[32, 16, 24]			,				snake_case_		: Optional[Any]=[16, 24, 40]			,				snake_case_		: str=[1, 1, 2]			,				snake_case_		: Union[str, Any]=[1, 1, 2]			,				snake_case_		: str=[1, 6, 6]			,				snake_case_		: int=True			,				snake_case_		: str=True			,				snake_case_		: List[Any]=37			,				snake_case_		: List[str]="gelu"			,				snake_case_		: Tuple=10			,				)   ->							Union[str, Any]:




     '''simple docstring'''

     A__ =       parent
     A__ =       batch_size
     A__ =       image_size
     A__ =       num_channels
     A__ =       kernel_sizes
     A__ =       in_channels
     A__ =       out_channels
     A__ =       strides
     A__ =       num_block_repeats
     A__ =       expand_ratios
     A__ =       is_training
     A__ =       hidden_act
     A__ =       num_labels
     A__ =       use_labels




    def 							__magic_name__							(					self		: Dict   )   ->							Tuple:




     '''simple docstring'''

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

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

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




    def 							__magic_name__							(					self		: Optional[int]   )   ->							List[str]:




     '''simple docstring'''

     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 							__magic_name__							(					self		: Optional[Any]			,				snake_case_		: List[Any]			,				snake_case_		: int			,				snake_case_		: Dict   )   ->							Optional[Any]:




     '''simple docstring'''

     A__ =       EfficientNetModel(config=snake_case_   )
     model.to(snake_case_   )
     model.eval()
     A__ =       model(snake_case_   )
     # 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 							__magic_name__							(					self		: Optional[int]			,				snake_case_		: Tuple			,				snake_case_		: Tuple			,				snake_case_		: Optional[Any]   )   ->							List[str]:




     '''simple docstring'''

     A__ =       EfficientNetForImageClassification(snake_case_   )
     model.to(snake_case_   )
     model.eval()
     A__ =       model(snake_case_			,				labels=snake_case_   )
     self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)   )




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




     '''simple docstring'''

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






@require_torch
class 			UpperCAmelCase_						(		A_,     A_,     unittest.TestCase							):
    lowercase__		      =   (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
    lowercase__		      =   (
        {'''feature-extraction''': EfficientNetModel, '''image-classification''': EfficientNetForImageClassification}
        if is_torch_available()
        else {}
    )

    lowercase__		      =   False
    lowercase__		      =   False
    lowercase__		      =   False
    lowercase__		      =   False
    lowercase__		      =   False




    def 							__magic_name__							(					self		: str   )   ->							Any:




     '''simple docstring'''

     A__ =       EfficientNetModelTester(self   )
     A__ =       ConfigTester(
         self			,				config_class=snake_case_			,				has_text_modality=snake_case_			,				hidden_size=37   )




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




     '''simple docstring'''

     return




    @unittest.skip(reason="EfficientNet does not use inputs_embeds"   )
    def 							__magic_name__							(					self		: List[Any]   )   ->							Tuple:




     '''simple docstring'''

     pass




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




     '''simple docstring'''

     pass




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




     '''simple docstring'''

     pass




    def 							__magic_name__							(					self		: Tuple   )   ->							Any:




     '''simple docstring'''

     A__,   A__ =       self.model_tester.prepare_config_and_inputs_for_common()

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

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




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




     '''simple docstring'''

     A__ =       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*snake_case_   )




    def 							__magic_name__							(					self		: str   )   ->							str:




     '''simple docstring'''

     def check_hidden_states_output(snake_case_		: List[str]			,				snake_case_		: Any			,				snake_case_		: List[str]   ):
      A__ =       model_class(snake_case_   )
      model.to(snake_case_   )
      model.eval()

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

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

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

     A__,   A__ =       self.model_tester.prepare_config_and_inputs_for_common()

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

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

      check_hidden_states_output(snake_case_			,				snake_case_			,				snake_case_   )




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




     '''simple docstring'''

     A__ =       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*snake_case_   )




    @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."   )
    def 							__magic_name__							(					self		: Any   )   ->							Union[str, Any]:




     '''simple docstring'''

     pass




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




     '''simple docstring'''

     for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      A__ =       EfficientNetModel.from_pretrained(snake_case_   )
      self.assertIsNotNone(snake_case_   )




    @is_pipeline_test
    @require_vision
    @slow
    def 							__magic_name__							(					self		: Optional[int]   )   ->							str:




     '''simple docstring'''

     super().test_pipeline_image_classification()







def 						_SCREAMING_SNAKE_CASE     (							)		->	Optional[Any]:
 A__ =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
 return image






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




    @cached_property
    def 							__magic_name__							(					self		: Dict   )   ->							List[str]:




     '''simple docstring'''

     return AutoImageProcessor.from_pretrained("google/efficientnet-b7"   ) if is_vision_available() else None




    @slow
    def 							__magic_name__							(					self		: Dict   )   ->							Union[str, Any]:




     '''simple docstring'''

     A__ =       EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7"   ).to(snake_case_   )

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

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

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

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











"""simple docstring"""



from typing import Optional, Union

from ...file_utils import TensorType
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, TruncationStrategy




class 			UpperCAmelCase_						(		A_							):
    lowercase__		      =   '''MarkupLMFeatureExtractor'''
    lowercase__		      =   ('''MarkupLMTokenizer''', '''MarkupLMTokenizerFast''')
    lowercase__		      =   True




    def __call__(					self		: Dict			,				snake_case_		: Optional[int]=None			,				snake_case_		: Union[str, Any]=None			,				snake_case_		: Tuple=None			,				snake_case_		: str=None			,				snake_case_		: Optional[Any]=None			,				snake_case_		: bool = True			,				snake_case_		: Union[bool, str, PaddingStrategy] = False			,				snake_case_		: Union[bool, str, TruncationStrategy] = None			,				snake_case_		: Optional[int] = None			,				snake_case_		: int = 0			,				snake_case_		: Optional[int] = None			,				snake_case_		: Optional[bool] = None			,				snake_case_		: Optional[bool] = None			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = True			,				snake_case_		: Optional[Union[str, TensorType]] = None			,				**snake_case_		: Dict			,				)   ->							BatchEncoding:




     '''simple docstring'''

     if self.parse_html:
      if html_strings is None:
       raise ValueError("Make sure to pass HTML strings in case `parse_html` is set to `True`"   )

      if nodes is not None or xpaths is not None or node_labels is not None:
       raise ValueError(
           "Please don't pass nodes, xpaths nor node labels in case `parse_html` is set to `True`"   )

      A__ =       self.feature_extractor(snake_case_   )
      A__ =       features["nodes"]
      A__ =       features["xpaths"]
     else:
      if html_strings is not None:
       raise ValueError("You have passed HTML strings but `parse_html` is set to `False`."   )
      if nodes is None or xpaths is None:
       raise ValueError("Make sure to pass nodes and xpaths in case `parse_html` is set to `False`"   )

        # # second, apply the tokenizer
     if questions is not None and self.parse_html:
      if isinstance(snake_case_			,				snake_case_   ):
       A__ =       [questions]  # add batch dimension (as the feature extractor always adds a batch dimension)

     A__ =       self.tokenizer(
         text=questions if questions is not None else nodes			,				text_pair=nodes if questions is not None else None			,				xpaths=snake_case_			,				node_labels=snake_case_			,				add_special_tokens=snake_case_			,				padding=snake_case_			,				truncation=snake_case_			,				max_length=snake_case_			,				stride=snake_case_			,				pad_to_multiple_of=snake_case_			,				return_token_type_ids=snake_case_			,				return_attention_mask=snake_case_			,				return_overflowing_tokens=snake_case_			,				return_special_tokens_mask=snake_case_			,				return_offsets_mapping=snake_case_			,				return_length=snake_case_			,				verbose=snake_case_			,				return_tensors=snake_case_			,				**snake_case_			,				)

     return encoded_inputs




    def 							__magic_name__							(					self		: Optional[Any]			,				*snake_case_		: Any			,				**snake_case_		: Any   )   ->							int:




     '''simple docstring'''

     return self.tokenizer.batch_decode(*snake_case_			,				**snake_case_   )




    def 							__magic_name__							(					self		: Tuple			,				*snake_case_		: Optional[Any]			,				**snake_case_		: List[Any]   )   ->							Any:




     '''simple docstring'''

     return self.tokenizer.decode(*snake_case_			,				**snake_case_   )




    @property
    def 							__magic_name__							(					self		: List[Any]   )   ->							Optional[int]:




     '''simple docstring'''

     A__ =       self.tokenizer.model_input_names
     return tokenizer_input_names





