

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_        =      get_tests_dir('fixtures')

class 				a  (	unittest.TestCase				):


      def        _UpperCAmelCase				(       self	):







          '''simple docstring'''


          _UpperCAmelCase       :		List[Any] 		=    mock.Mock()
          _UpperCAmelCase       :		Tuple 		=    500
          _UpperCAmelCase       :		Dict 		=    {}
          _UpperCAmelCase       :		Dict 		=    HTTPError
          _UpperCAmelCase       :		Optional[Any] 		=    {}

          # Download this model to make sure it's in the cache.
          _UpperCAmelCase       :		Any 		=    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:
              _UpperCAmelCase       :		Optional[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'''


          _UpperCAmelCase       :		List[Any] 		=    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
              _UpperCAmelCase       :		str 		=    AutoImageProcessor.from_pretrained("hf-internal-testing/stable-diffusion-all-variants"	)

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

          self.assertIsNotNone(_A	)







@is_staging_test
class 				a  (	unittest.TestCase				):


      @classmethod
      def        _UpperCAmelCase				(       cls	):







          '''simple docstring'''


          _UpperCAmelCase       :		int 		=    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'''


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

          _UpperCAmelCase       :		Tuple 		=    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	)

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


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

          _UpperCAmelCase       :		Dict 		=    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	)

          _UpperCAmelCase       :		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()
          _UpperCAmelCase       :		List[Any] 		=    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"}						,					)

          _UpperCAmelCase       :		Tuple 		=    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"	)





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE_        =      {
    'configuration_nllb_moe': [
        'NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'NllbMoeConfig',
    ]
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE_        =      [
					    'NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'NllbMoeForConditionalGeneration',
					    'NllbMoeModel',
					    'NllbMoePreTrainedModel',
					    'NllbMoeTop2Router',
					    'NllbMoeSparseMLP',
					]


if TYPE_CHECKING:
					from .configuration_nllb_moe import (
					    NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    NllbMoeConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_nllb_moe import (
										    NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST,
										    NllbMoeForConditionalGeneration,
										    NllbMoeModel,
										    NllbMoePreTrainedModel,
										    NllbMoeSparseMLP,
										    NllbMoeTopaRouter,
										)


else:
					import sys

					SCREAMING_SNAKE_CASE_        =      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


