


import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        SqueezeBertForMaskedLM,
        SqueezeBertForMultipleChoice,
        SqueezeBertForQuestionAnswering,
        SqueezeBertForSequenceClassification,
        SqueezeBertForTokenClassification,
        SqueezeBertModel,
    )



class 	__lowerCamelCase			(_a						):







       def __init__(			self: Optional[int],A_: Dict,A_: List[str]=13,A_: List[str]=7,A_: Dict=True,A_: Any=True,A_: Optional[Any]=False,A_: Any=True,A_: List[Any]=99,A_: Optional[Any]=32,A_: Union[str, Any]=5,A_: str=4,A_: Optional[int]=64,A_: Tuple="gelu",A_: Optional[int]=0.1,A_: str=0.1,A_: Union[str, Any]=512,A_: Optional[Any]=16,A_: Any=2,A_: Dict=0.0_2,A_: Dict=3,A_: List[Any]=4,A_: Optional[Any]=None,A_: Tuple=2,A_: Optional[int]=2,A_: int=2,A_: List[Any]=2,A_: Optional[Any]=4,A_: Any=1,):






            '''simple docstring'''




            __UpperCamelCase =			parent
            __UpperCamelCase =			batch_size
            __UpperCamelCase =			seq_length
            __UpperCamelCase =			is_training
            __UpperCamelCase =			use_input_mask
            __UpperCamelCase =			use_token_type_ids
            __UpperCamelCase =			use_labels
            __UpperCamelCase =			vocab_size
            __UpperCamelCase =			hidden_size
            __UpperCamelCase =			num_hidden_layers
            __UpperCamelCase =			num_attention_heads
            __UpperCamelCase =			intermediate_size
            __UpperCamelCase =			hidden_act
            __UpperCamelCase =			hidden_dropout_prob
            __UpperCamelCase =			attention_probs_dropout_prob
            __UpperCamelCase =			max_position_embeddings
            __UpperCamelCase =			type_vocab_size
            __UpperCamelCase =			type_sequence_label_size
            __UpperCamelCase =			initializer_range
            __UpperCamelCase =			num_labels
            __UpperCamelCase =			num_choices
            __UpperCamelCase =			scope
            __UpperCamelCase =			q_groups
            __UpperCamelCase =			k_groups
            __UpperCamelCase =			v_groups
            __UpperCamelCase =			post_attention_groups
            __UpperCamelCase =			intermediate_groups
            __UpperCamelCase =			output_groups







       def 		snake_case_	(			self: Optional[int]					):






            '''simple docstring'''




            __UpperCamelCase =			ids_tensor([self.batch_size, self.seq_length],self.vocab_size					)

            __UpperCamelCase =			None
            if self.use_input_mask:
                 __UpperCamelCase =			random_attention_mask([self.batch_size, self.seq_length]					)

            __UpperCamelCase =			None
            __UpperCamelCase =			None
            __UpperCamelCase =			None
            if self.use_labels:
                 __UpperCamelCase =			ids_tensor([self.batch_size],self.type_sequence_label_size					)
                 __UpperCamelCase =			ids_tensor([self.batch_size, self.seq_length],self.num_labels					)
                 __UpperCamelCase =			ids_tensor([self.batch_size],self.num_choices					)

            __UpperCamelCase =			self.get_config()

            return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels







       def 		snake_case_	(			self: List[Any]					):






            '''simple docstring'''




            return SqueezeBertConfig(
                embedding_size=self.hidden_size,vocab_size=self.vocab_size,hidden_size=self.hidden_size,num_hidden_layers=self.num_hidden_layers,num_attention_heads=self.num_attention_heads,intermediate_size=self.intermediate_size,hidden_act=self.hidden_act,attention_probs_dropout_prob=self.hidden_dropout_prob,attention_dropout=self.attention_probs_dropout_prob,max_position_embeddings=self.max_position_embeddings,initializer_range=self.initializer_range,q_groups=self.q_groups,k_groups=self.k_groups,v_groups=self.v_groups,post_attention_groups=self.post_attention_groups,intermediate_groups=self.intermediate_groups,output_groups=self.output_groups,)







       def 		snake_case_	(			self: List[str],A_: str,A_: str,A_: str,A_: List[Any],A_: Any,A_: Optional[Any]					):






            '''simple docstring'''




            __UpperCamelCase =			SqueezeBertModel(config=A_					)
            model.to(A_					)
            model.eval()
            __UpperCamelCase =			model(A_,A_					)
            __UpperCamelCase =			model(A_					)
            self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size)					)







       def 		snake_case_	(			self: int,A_: Optional[Any],A_: List[Any],A_: List[str],A_: List[str],A_: Optional[Any],A_: Optional[int]					):






            '''simple docstring'''




            __UpperCamelCase =			SqueezeBertForMaskedLM(config=A_					)
            model.to(A_					)
            model.eval()
            __UpperCamelCase =			model(A_,attention_mask=A_,labels=A_					)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.vocab_size)					)







       def 		snake_case_	(			self: str,A_: str,A_: Union[str, Any],A_: Tuple,A_: Any,A_: List[str],A_: Dict					):






            '''simple docstring'''




            __UpperCamelCase =			SqueezeBertForQuestionAnswering(config=A_					)
            model.to(A_					)
            model.eval()
            __UpperCamelCase =			model(
                A_,attention_mask=A_,start_positions=A_,end_positions=A_					)
            self.parent.assertEqual(result.start_logits.shape,(self.batch_size, self.seq_length)					)
            self.parent.assertEqual(result.end_logits.shape,(self.batch_size, self.seq_length)					)







       def 		snake_case_	(			self: Optional[int],A_: Optional[int],A_: List[str],A_: int,A_: Optional[int],A_: Dict,A_: int					):






            '''simple docstring'''




            __UpperCamelCase =			self.num_labels
            __UpperCamelCase =			SqueezeBertForSequenceClassification(A_					)
            model.to(A_					)
            model.eval()
            __UpperCamelCase =			model(A_,attention_mask=A_,labels=A_					)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels)					)







       def 		snake_case_	(			self: str,A_: Any,A_: str,A_: Optional[Any],A_: Optional[Any],A_: Optional[Any],A_: Dict					):






            '''simple docstring'''




            __UpperCamelCase =			self.num_labels
            __UpperCamelCase =			SqueezeBertForTokenClassification(config=A_					)
            model.to(A_					)
            model.eval()

            __UpperCamelCase =			model(A_,attention_mask=A_,labels=A_					)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.num_labels)					)







       def 		snake_case_	(			self: Union[str, Any],A_: Tuple,A_: str,A_: Any,A_: Union[str, Any],A_: Dict,A_: str					):






            '''simple docstring'''




            __UpperCamelCase =			self.num_choices
            __UpperCamelCase =			SqueezeBertForMultipleChoice(config=A_					)
            model.to(A_					)
            model.eval()
            __UpperCamelCase =			input_ids.unsqueeze(1					).expand(-1,self.num_choices,-1					).contiguous()
            __UpperCamelCase =			input_mask.unsqueeze(1					).expand(-1,self.num_choices,-1					).contiguous()
            __UpperCamelCase =			model(
                A_,attention_mask=A_,labels=A_,)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_choices)					)







       def 		snake_case_	(			self: Dict					):






            '''simple docstring'''




            __UpperCamelCase =			self.prepare_config_and_inputs()
            ((__UpperCamelCase),    (__UpperCamelCase),    (__UpperCamelCase),    (__UpperCamelCase),    (__UpperCamelCase),    (__UpperCamelCase)) =			config_and_inputs
            __UpperCamelCase =			{'input_ids': input_ids, 'attention_mask': input_mask}
            return config, inputs_dict



@require_torch
class 	__lowerCamelCase			(_a				,      _a				,      unittest.TestCase						):
       _lowercase											=     (
           (
               SqueezeBertModel,
               SqueezeBertForMaskedLM,
               SqueezeBertForMultipleChoice,
               SqueezeBertForQuestionAnswering,
               SqueezeBertForSequenceClassification,
               SqueezeBertForTokenClassification,
           )
           if is_torch_available()
           else None
       )
       _lowercase											=     (
           {
               """feature-extraction""": SqueezeBertModel,
               """fill-mask""": SqueezeBertForMaskedLM,
               """question-answering""": SqueezeBertForQuestionAnswering,
               """text-classification""": SqueezeBertForSequenceClassification,
               """token-classification""": SqueezeBertForTokenClassification,
               """zero-shot""": SqueezeBertForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       _lowercase											=     False
       _lowercase											=     True
       _lowercase											=     False







       def 		snake_case_	(			self: Union[str, Any]					):






            '''simple docstring'''




            __UpperCamelCase =			SqueezeBertModelTester(self					)
            __UpperCamelCase =			ConfigTester(self,config_class=A_,dim=37					)







       def 		snake_case_	(			self: int					):






            '''simple docstring'''




            self.config_tester.run_common_tests()







       def 		snake_case_	(			self: str					):






            '''simple docstring'''




            __UpperCamelCase =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_squeezebert_model(*A_					)







       def 		snake_case_	(			self: Any					):






            '''simple docstring'''




            __UpperCamelCase =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_squeezebert_for_masked_lm(*A_					)







       def 		snake_case_	(			self: Dict					):






            '''simple docstring'''




            __UpperCamelCase =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_squeezebert_for_question_answering(*A_					)







       def 		snake_case_	(			self: Union[str, Any]					):






            '''simple docstring'''




            __UpperCamelCase =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_squeezebert_for_sequence_classification(*A_					)







       def 		snake_case_	(			self: Optional[Any]					):






            '''simple docstring'''




            __UpperCamelCase =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_squeezebert_for_token_classification(*A_					)







       def 		snake_case_	(			self: Any					):






            '''simple docstring'''




            __UpperCamelCase =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_squeezebert_for_multiple_choice(*A_					)







       @slow
       def 		snake_case_	(			self: int					):






            '''simple docstring'''




            for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __UpperCamelCase =			SqueezeBertModel.from_pretrained(A_					)
                 self.assertIsNotNone(A_					)



@require_sentencepiece
@require_tokenizers
@require_torch
class 	__lowerCamelCase			(unittest.TestCase						):







       @slow
       def 		snake_case_	(			self: List[Any]					):






            '''simple docstring'''




            __UpperCamelCase =			SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli'					)

            __UpperCamelCase =			torch.tensor([[1, 2_9414, 232, 328, 740, 1140, 1_2695, 69, 13, 1588, 2]]					)
            __UpperCamelCase =			model(A_					)[0]
            __UpperCamelCase =			torch.Size((1, 3)					)
            self.assertEqual(output.shape,A_					)
            __UpperCamelCase =			torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]					)
            self.assertTrue(torch.allclose(A_,A_,atol=1E-4					)					)








'''simple docstring'''



import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoImageProcessor, ViTImageProcessor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


UpperCamelCase_    	=				get_tests_dir("fixtures")






class 							_a				(			unittest.TestCase ):





       '''simple docstring'''






       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						mock.Mock()
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						500
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						{}
             SCREAMING_SNAKE_CASE   :      Any    					=						HTTPError
             SCREAMING_SNAKE_CASE   :      Any    					=						{}

             # Download this model to make sure it's in the cache.
             SCREAMING_SNAKE_CASE   :      str    					=						ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'  )
             # Under the mock environment we get a 500 error when trying to reach the model.
             with mock.patch('requests.Session.request',							return_value=A  ) as mock_head:
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'  )
                   # This check we did call the fake head request
                   mock_head.assert_called()







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						ViTImageProcessor.from_pretrained(
                 'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             with self.assertRaises(A  ):
                   # config is in subfolder, the following should not work without specifying the subfolder
                   SCREAMING_SNAKE_CASE   :      str    					=						AutoImageProcessor.from_pretrained('hf-internal-testing/stable-diffusion-all-variants'  )

             SCREAMING_SNAKE_CASE   :      Dict    					=						AutoImageProcessor.from_pretrained(
                 'hf-internal-testing/stable-diffusion-all-variants',							subfolder='feature_extractor'  )

             self.assertIsNotNone(A  )






@is_staging_test
class 							_a				(			unittest.TestCase ):





       '''simple docstring'''






       @classmethod
       def        UpperCamelCase_							(      cls  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						TOKEN
             HfFolder.save_token(A  )







       @classmethod
       def        UpperCamelCase_							(      cls  ):







             '''simple docstring'''







             try:
                   delete_repo(token=cls._token,							repo_id='test-image-processor'  )
             except HTTPError:
                   pass

             try:
                   delete_repo(token=cls._token,							repo_id='valid_org/test-image-processor-org'  )
             except HTTPError:
                   pass

             try:
                   delete_repo(token=cls._token,							repo_id='test-dynamic-image-processor'  )
             except HTTPError:
                   pass







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						ViTImageProcessor.from_pretrained(A  )
             image_processor.push_to_hub('test-image-processor',							use_auth_token=self._token  )

             SCREAMING_SNAKE_CASE   :      int    					=						ViTImageProcessor.from_pretrained(F"{USER}/test-image-processor"  )
             for k, v in image_processor.__dict__.items():
                   self.assertEqual(A,							getattr(A,							A  )  )

             # Reset repo
             delete_repo(token=self._token,							repo_id='test-image-processor'  )

             # Push to hub via save_pretrained
             with tempfile.TemporaryDirectory() as tmp_dir:
                   image_processor.save_pretrained(
                       A,							repo_id='test-image-processor',							push_to_hub=A,							use_auth_token=self._token  )

             SCREAMING_SNAKE_CASE   :      List[str]    					=						ViTImageProcessor.from_pretrained(F"{USER}/test-image-processor"  )
             for k, v in image_processor.__dict__.items():
                   self.assertEqual(A,							getattr(A,							A  )  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[Any]    					=						ViTImageProcessor.from_pretrained(A  )
             image_processor.push_to_hub('valid_org/test-image-processor',							use_auth_token=self._token  )

             SCREAMING_SNAKE_CASE   :      str    					=						ViTImageProcessor.from_pretrained('valid_org/test-image-processor'  )
             for k, v in image_processor.__dict__.items():
                   self.assertEqual(A,							getattr(A,							A  )  )

             # Reset repo
             delete_repo(token=self._token,							repo_id='valid_org/test-image-processor'  )

             # Push to hub via save_pretrained
             with tempfile.TemporaryDirectory() as tmp_dir:
                   image_processor.save_pretrained(
                       A,							repo_id='valid_org/test-image-processor-org',							push_to_hub=A,							use_auth_token=self._token  )

             SCREAMING_SNAKE_CASE   :      Dict    					=						ViTImageProcessor.from_pretrained('valid_org/test-image-processor-org'  )
             for k, v in image_processor.__dict__.items():
                   self.assertEqual(A,							getattr(A,							A  )  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             CustomImageProcessor.register_for_auto_class()
             SCREAMING_SNAKE_CASE   :      Tuple    					=						CustomImageProcessor.from_pretrained(A  )

             image_processor.push_to_hub('test-dynamic-image-processor',							use_auth_token=self._token  )

             # This has added the proper auto_map field to the config
             self.assertDictEqual(
                 image_processor.auto_map,							{'AutoImageProcessor': 'custom_image_processing.CustomImageProcessor'},							)

             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						AutoImageProcessor.from_pretrained(
                 F"{USER}/test-dynamic-image-processor",							trust_remote_code=A  )
             # Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
             self.assertEqual(new_image_processor.__class__.__name__,							'CustomImageProcessor'  )


