




'''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  __lowercase    (	unittest.TestCase			):







   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     # A mock response for an HTTP head request to emulate server down
     __a								=       mock.Mock()
     __a								=       500
     __a								=       {}
     __a								=       HTTPError
     __a								=       {}

     # Download this model to make sure it's in the cache.
     __a								=       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=UpperCamelCase   ) as mock_head:
       __a								=       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   )					->     Tuple:
     # This test is for deprecated behavior and can be removed in v5
     __a								=       ViTImageProcessor.from_pretrained(
         'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'   )







   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     with self.assertRaises(UpperCamelCase   ):
       # config is in subfolder, the following should not work without specifying the subfolder
       __a								=       AutoImageProcessor.from_pretrained('hf-internal-testing/stable-diffusion-all-variants'   )

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

     self.assertIsNotNone(UpperCamelCase   )





@is_staging_test
class  __lowercase    (	unittest.TestCase			):







   @classmethod
   def 		UpperCamelCase__      (						cls   )					->     Optional[int]:
     __a								=       TOKEN
     HfFolder.save_token(UpperCamelCase   )







   @classmethod
   def 		UpperCamelCase__      (						cls   )					->     Union[str, Any]:
     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   )					->     List[str]:
     __a								=       ViTImageProcessor.from_pretrained(UpperCamelCase   )
     image_processor.push_to_hub('test-image-processor'   ,				use_auth_token=self._token   )

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

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

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







   def 		UpperCamelCase__      (						self   )					->     Optional[int]:
     __a								=       ViTImageProcessor.from_pretrained(UpperCamelCase   )
     image_processor.push_to_hub('valid_org/test-image-processor'   ,				use_auth_token=self._token   )

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

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

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







   def 		UpperCamelCase__      (						self   )					->     List[Any]:
     CustomImageProcessor.register_for_auto_class()
     __a								=       CustomImageProcessor.from_pretrained(UpperCamelCase   )

     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								=       AutoImageProcessor.from_pretrained(
         f"{USER}/test-dynamic-image-processor"   ,				trust_remote_code=UpperCamelCase   )
     # 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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_					=   {
    "configuration_time_series_transformer": [
        "TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "TimeSeriesTransformerConfig",
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_					=   [
      "TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
      "TimeSeriesTransformerForPrediction",
      "TimeSeriesTransformerModel",
      "TimeSeriesTransformerPreTrainedModel",
  ]


if TYPE_CHECKING:
  from .configuration_time_series_transformer import (
      TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
      TimeSeriesTransformerConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_time_series_transformer import (
        TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        TimeSeriesTransformerForPrediction,
        TimeSeriesTransformerModel,
        TimeSeriesTransformerPreTrainedModel,
    )

else:
  import sys

  UpperCAmelCase_					=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



