






'''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


__A							:							Dict  							=		get_tests_dir("""fixtures""")
class 				lowercase       (							unittest.TestCase      ):


				'''simple docstring'''

				def    a__				(					self     :     Tuple     )							->							List[str]:

					'''simple docstring'''




					lowerCamelCase__  =     mock.Mock()
					lowerCamelCase__  =     500
					lowerCamelCase__  =     {}
					lowerCamelCase__  =     HTTPError
					lowerCamelCase__  =     {}

					# Download this model to make sure it's in the cache.
					lowerCamelCase__  =     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:
						lowerCamelCase__  =     ViTImageProcessor.from_pretrained("hf-internal-testing/tiny-random-vit"     )
						# This check we did call the fake head request
						mock_head.assert_called()

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

					'''simple docstring'''




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




				def    a__				(					self     :     Any     )							->							Tuple:

					'''simple docstring'''




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

					lowerCamelCase__  =     AutoImageProcessor.from_pretrained(
					    "hf-internal-testing/stable-diffusion-all-variants"				,     subfolder="feature_extractor"     )

					self.assertIsNotNone(_A     )
@is_staging_test
class 				lowercase       (							unittest.TestCase      ):


				'''simple docstring'''

				@classmethod
				def    a__				(					cls     :     Any     )							->							Union[str, Any]:

					'''simple docstring'''




					lowerCamelCase__  =     TOKEN
					HfFolder.save_token(_A     )

				@classmethod
				def    a__				(					cls     :     int     )							->							Optional[int]:

					'''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    a__				(					self     :     List[Any]     )							->							List[str]:

					'''simple docstring'''




					lowerCamelCase__  =     ViTImageProcessor.from_pretrained(_A     )
					image_processor.push_to_hub("test-image-processor"				,     use_auth_token=self._token     )

					lowerCamelCase__  =     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     )

					lowerCamelCase__  =     ViTImageProcessor.from_pretrained(f'''{USER}/test-image-processor'''     )
					for k, v in image_processor.__dict__.items():
						self.assertEqual(_A				,     getattr(_A				,     _A     )     )

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

					'''simple docstring'''




					lowerCamelCase__  =     ViTImageProcessor.from_pretrained(_A     )
					image_processor.push_to_hub("valid_org/test-image-processor"				,     use_auth_token=self._token     )

					lowerCamelCase__  =     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     )

					lowerCamelCase__  =     ViTImageProcessor.from_pretrained("valid_org/test-image-processor-org"     )
					for k, v in image_processor.__dict__.items():
						self.assertEqual(_A				,     getattr(_A				,     _A     )     )




				def    a__				(					self     :     Dict     )							->							str:

					'''simple docstring'''




					CustomImageProcessor.register_for_auto_class()
					lowerCamelCase__  =     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"}				,     )

					lowerCamelCase__  =     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"     )









'''simple docstring'''





from __future__ import annotations

import unittest

from transformers import BlenderbotSmallConfig, BlenderbotSmallTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel
@require_tf
class 				lowercase       :


    '''simple docstring'''

    lowerCAmelCase__      				=							BlenderbotSmallConfig
    lowerCAmelCase__      				=							{}
    lowerCAmelCase__      				=							"gelu"

    def __init__(					self     :     List[Any]				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     str=13				,     __lowerCamelCase     :     List[str]=7				,     __lowerCamelCase     :     Dict=True				,     __lowerCamelCase     :     Any=False				,     __lowerCamelCase     :     Union[str, Any]=99				,     __lowerCamelCase     :     Optional[int]=32				,     __lowerCamelCase     :     Optional[int]=2				,     __lowerCamelCase     :     List[str]=4				,     __lowerCamelCase     :     Union[str, Any]=37				,     __lowerCamelCase     :     Tuple=0.1				,     __lowerCamelCase     :     List[str]=0.1				,     __lowerCamelCase     :     int=20				,     __lowerCamelCase     :     Optional[Any]=2				,     __lowerCamelCase     :     List[str]=1				,     __lowerCamelCase     :     Union[str, Any]=0				,     )							->							str:

     '''simple docstring'''




     lowerCamelCase__  =     parent
     lowerCamelCase__  =     batch_size
     lowerCamelCase__  =     seq_length
     lowerCamelCase__  =     is_training
     lowerCamelCase__  =     use_labels
     lowerCamelCase__  =     vocab_size
     lowerCamelCase__  =     hidden_size
     lowerCamelCase__  =     num_hidden_layers
     lowerCamelCase__  =     num_attention_heads
     lowerCamelCase__  =     intermediate_size

     lowerCamelCase__  =     hidden_dropout_prob
     lowerCamelCase__  =     attention_probs_dropout_prob
     lowerCamelCase__  =     max_position_embeddings
     lowerCamelCase__  =     eos_token_id
     lowerCamelCase__  =     pad_token_id
     lowerCamelCase__  =     bos_token_id

    def    a__				(					self     :     str     )							->							List[str]:

     '''simple docstring'''




     lowerCamelCase__  =     ids_tensor([self.batch_size, self.seq_length - 1]				,     self.vocab_size     )
     lowerCamelCase__  =     tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size     )				,     1     )
     lowerCamelCase__  =     tf.concat([input_ids, eos_tensor]				,     axis=1     )

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

     lowerCamelCase__  =     self.config_cls(
         vocab_size=self.vocab_size				,     d_model=self.hidden_size				,     encoder_layers=self.num_hidden_layers				,     decoder_layers=self.num_hidden_layers				,     encoder_attention_heads=self.num_attention_heads				,     decoder_attention_heads=self.num_attention_heads				,     encoder_ffn_dim=self.intermediate_size				,     decoder_ffn_dim=self.intermediate_size				,     dropout=self.hidden_dropout_prob				,     attention_dropout=self.attention_probs_dropout_prob				,     max_position_embeddings=self.max_position_embeddings				,     eos_token_ids=[2]				,     bos_token_id=self.bos_token_id				,     pad_token_id=self.pad_token_id				,     decoder_start_token_id=self.pad_token_id				,     **self.config_updates				,     )
     lowerCamelCase__  =     prepare_blenderbot_small_inputs_dict(__lowerCamelCase				,     __lowerCamelCase				,     __lowerCamelCase     )
     return config, inputs_dict




    def    a__				(					self     :     int				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     Optional[Any]     )							->							Tuple:

     '''simple docstring'''




     lowerCamelCase__  =     TFBlenderbotSmallModel(config=__lowerCamelCase     ).get_decoder()
     lowerCamelCase__  =     inputs_dict["input_ids"]

     lowerCamelCase__  =     input_ids[:1, :]
     lowerCamelCase__  =     inputs_dict["attention_mask"][:1, :]
     lowerCamelCase__  =     inputs_dict["head_mask"]
     lowerCamelCase__  =     1

     # first forward pass
     lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase				,     head_mask=__lowerCamelCase				,     use_cache=__lowerCamelCase     )

     lowerCamelCase__  ,	lowerCamelCase__  =     outputs.to_tuple()

     # create hypothetical next token and extent to next_input_ids
     lowerCamelCase__  =     ids_tensor((self.batch_size, 3)				,     config.vocab_size     )
     lowerCamelCase__  =     tf.cast(ids_tensor((self.batch_size, 3)				,     2     )				,     tf.inta     )

     # append to next input_ids and
     lowerCamelCase__  =     tf.concat([input_ids, next_tokens]				,     axis=-1     )
     lowerCamelCase__  =     tf.concat([attention_mask, next_attn_mask]				,     axis=-1     )

     lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase     )[0]
     lowerCamelCase__  =     model(__lowerCamelCase				,     attention_mask=__lowerCamelCase				,     past_key_values=__lowerCamelCase     )[0]

     self.parent.assertEqual(next_tokens.shape[1]				,     output_from_past.shape[1]     )

     # select random slice
     lowerCamelCase__  =     int(ids_tensor((1,)				,     output_from_past.shape[-1]     )     )
     lowerCamelCase__  =     output_from_no_past[:, -3:, random_slice_idx]
     lowerCamelCase__  =     output_from_past[:, :, random_slice_idx]

     # test that outputs are equal for slice
     tf.debugging.assert_near(__lowerCamelCase				,     __lowerCamelCase				,     rtol=1E-3     )






def    lowerCamelCase_     (    lowercase__				,     lowercase__				,     lowercase__				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     lowercase__=None				,     ):
 if attention_mask is None:
  lowerCamelCase__  =     tf.cast(tf.math.not_equal(lowercase__				,     config.pad_token_id)				,     tf.inta)
 if decoder_attention_mask is None:
  lowerCamelCase__  =     tf.concat(
      [
          tf.ones(decoder_input_ids[:, :1].shape				,     dtype=tf.inta),
          tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]				,     config.pad_token_id)				,     tf.inta),
      ]				,     axis=-1				,     )
 if head_mask is None:
  lowerCamelCase__  =     tf.ones((config.encoder_layers, config.encoder_attention_heads))
 if decoder_head_mask is None:
  lowerCamelCase__  =     tf.ones((config.decoder_layers, config.decoder_attention_heads))
 if cross_attn_head_mask is None:
  lowerCamelCase__  =     tf.ones((config.decoder_layers, config.decoder_attention_heads))
 return {
     "input_ids": input_ids,
     "decoder_input_ids": decoder_input_ids,
     "attention_mask": attention_mask,
     "decoder_attention_mask": decoder_attention_mask,
     "head_mask": head_mask,
     "decoder_head_mask": decoder_head_mask,
     "cross_attn_head_mask": cross_attn_head_mask,
 }
@require_tf
class 				lowercase       (							_lowerCamelCase ,       _lowerCamelCase ,       unittest.TestCase      ):


    '''simple docstring'''

    lowerCAmelCase__      				=							(
        (TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel) if is_tf_available() else ()
    )
    lowerCAmelCase__      				=							(TFBlenderbotSmallForConditionalGeneration,) if is_tf_available() else ()
    lowerCAmelCase__      				=							(
        {
            "conversational": TFBlenderbotSmallForConditionalGeneration,
            "feature-extraction": TFBlenderbotSmallModel,
            "summarization": TFBlenderbotSmallForConditionalGeneration,
            "text2text-generation": TFBlenderbotSmallForConditionalGeneration,
            "translation": TFBlenderbotSmallForConditionalGeneration,
        }
        if is_tf_available()
        else {}
    )
    lowerCAmelCase__      				=							True
    lowerCAmelCase__      				=							False
    lowerCAmelCase__      				=							False

    def    a__				(					self     :     List[Any]     )							->							Optional[Any]:

     '''simple docstring'''




     lowerCamelCase__  =     TFBlenderbotSmallModelTester(self     )
     lowerCamelCase__  =     ConfigTester(self				,     config_class=__lowerCamelCase     )

    def    a__				(					self     :     Any     )							->							Tuple:

     '''simple docstring'''




     self.config_tester.run_common_tests()




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

     '''simple docstring'''




     lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs_for_common()
     self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase     )
@require_tokenizers
@require_tf
class 				lowercase       (							unittest.TestCase      ):


    '''simple docstring'''

    lowerCAmelCase__      				=							[
        "Social anxiety\nWow, I am never shy. Do you have anxiety?\nYes. I end up sweating and blushing and feel like "
        "  i'm going to throw up.\nand why is that?"
    ]
    lowerCAmelCase__      				=							"facebook/blenderbot_small-90M"

    @cached_property
    def    a__				(					self     :     Optional[Any]     )							->							Tuple:

     '''simple docstring'''




     return BlenderbotSmallTokenizer.from_pretrained("facebook/blenderbot-90M"     )

    @cached_property
    def    a__				(					self     :     int     )							->							int:

     '''simple docstring'''




     lowerCamelCase__  =     TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name     )
     return model




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

     '''simple docstring'''




     lowerCamelCase__  =     self.tokenizer(self.src_text				,     return_tensors="tf"     )
     lowerCamelCase__  =     self.model.generate(
         model_inputs.input_ids				,     attention_mask=model_inputs.attention_mask				,     num_beams=2				,     use_cache=__lowerCamelCase				,     )
     lowerCamelCase__  =     self.tokenizer.batch_decode(generated_ids.numpy()				,     skip_special_tokens=__lowerCamelCase     )[0]
     assert generated_words in (
         "i don't know. i just feel like i'm going to throw up. it's not fun.",
         "i'm not sure. i just feel like i've been feeling like i have to be in a certain place",
         "i'm not sure. i just feel like i've been in a bad situation.",
     )

