



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


SCREAMING_SNAKE_CASE_:Union[str, Any]             =						get_tests_dir("""fixtures""")






class SCREAMING_SNAKE_CASE__     (		unittest.TestCase    ):




    '''simple docstring'''






    def 			_lowerCAmelCase					(       self		):
        # A mock response for an HTTP head request to emulate server down
        A :       Union[str, Any]          =   mock.Mock()
        A :       int          =   500
        A :       Optional[Any]          =   {}
        A :       List[str]          =   HTTPError
        A :       Optional[int]          =   {}

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






    def 			_lowerCAmelCase					(       self		):
        # This test is for deprecated behavior and can be removed in v5
        A :       Tuple          =   ViTImageProcessor.from_pretrained(
            """https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"""		)






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

        A :       Optional[Any]          =   AutoImageProcessor.from_pretrained(
            """hf-internal-testing/stable-diffusion-all-variants""",		subfolder="""feature_extractor"""		)

        self.assertIsNotNone(lowerCamelCase__		)






@is_staging_test
class SCREAMING_SNAKE_CASE__     (		unittest.TestCase    ):




    '''simple docstring'''






    @classmethod
    def 			_lowerCAmelCase					(       cls		):
        A :       int          =   TOKEN
        HfFolder.save_token(lowerCamelCase__		)






    @classmethod
    def 			_lowerCAmelCase					(       cls		):
        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 			_lowerCAmelCase					(       self		):
        A :       Dict          =   ViTImageProcessor.from_pretrained(lowerCamelCase__		)
        image_processor.push_to_hub("""test-image-processor""",		use_auth_token=self._token		)

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

        # 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(
                lowerCamelCase__,		repo_id="""test-image-processor""",		push_to_hub=lowerCamelCase__,		use_auth_token=self._token		)

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






    def 			_lowerCAmelCase					(       self		):
        A :       List[str]          =   ViTImageProcessor.from_pretrained(lowerCamelCase__		)
        image_processor.push_to_hub("""valid_org/test-image-processor""",		use_auth_token=self._token		)

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

        # 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(
                lowerCamelCase__,		repo_id="""valid_org/test-image-processor-org""",		push_to_hub=lowerCamelCase__,		use_auth_token=self._token		)

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






    def 			_lowerCAmelCase					(       self		):
        CustomImageProcessor.register_for_auto_class()
        A :       Union[str, Any]          =   CustomImageProcessor.from_pretrained(lowerCamelCase__		)

        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"""},		)

        A :       int          =   AutoImageProcessor.from_pretrained(
            f'''{USER}/test-dynamic-image-processor''',		trust_remote_code=lowerCamelCase__		)
        # 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"""		)







from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow


if is_tf_available():
     import tensorflow as tf

     from transformers import AutoTokenizer, TFAutoModelForSeqaSeqLM






@require_tf
@require_sentencepiece
@require_tokenizers
class SCREAMING_SNAKE_CASE__     (		unittest.TestCase    ):




    '''simple docstring'''






    @slow
    def 			_lowerCAmelCase					(       self		):
        A :       Any          =   TFAutoModelForSeqaSeqLM.from_pretrained("""google/mt5-small"""		)
        A :       Dict          =   AutoTokenizer.from_pretrained("""google/mt5-small"""		)

        A :       Tuple          =   tokenizer("""Hello there""",		return_tensors="""tf"""		).input_ids
        A :       Optional[int]          =   tokenizer("""Hi I am""",		return_tensors="""tf"""		).input_ids

        A :       List[Any]          =   model(lowerCamelCase__,		labels=lowerCamelCase__		).loss
        A :       str          =   -tf.math.reduce_mean(lowerCamelCase__		).numpy()

        A :       Tuple          =   -21.22_8168
        self.assertTrue(abs(mtf_score - EXPECTED_SCORE		) < 2e-4		)


