


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

class 							lowercase  (						unittest.TestCase			):







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

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







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







     def 							lowercase__       (						self :						Tuple      ):
           with self.assertRaises(_lowercase      ):
                 # 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__       :  Union[str, Any]						     =		AutoImageProcessor.from_pretrained(
               '''hf-internal-testing/stable-diffusion-all-variants'''   ,   subfolder='''feature_extractor'''      )

           self.assertIsNotNone(_lowercase      )




@is_staging_test
class 							lowercase  (						unittest.TestCase			):







     @classmethod
     def 							lowercase__       (						cls :						int      ):
           SCREAMING_SNAKE_CASE__       :  int						     =		TOKEN
           HfFolder.save_token(_lowercase      )







     @classmethod
     def 							lowercase__       (						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 							lowercase__       (						self :						Optional[Any]      ):
           SCREAMING_SNAKE_CASE__       :  Dict						     =		ViTImageProcessor.from_pretrained(_lowercase      )
           image_processor.push_to_hub('''test-image-processor'''   ,   use_auth_token=self._token      )

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

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

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







     def 							lowercase__       (						self :						Union[str, Any]      ):
           SCREAMING_SNAKE_CASE__       :  Optional[int]						     =		ViTImageProcessor.from_pretrained(_lowercase      )
           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(_lowercase   ,   getattr(_lowercase   ,   _lowercase      )      )

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

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







     def 							lowercase__       (						self :						Optional[Any]      ):
           CustomImageProcessor.register_for_auto_class()
           SCREAMING_SNAKE_CASE__       :  Any						     =		CustomImageProcessor.from_pretrained(_lowercase      )

           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__       :  List[str]						     =		AutoImageProcessor.from_pretrained(
               f"""{USER}/test-dynamic-image-processor"""   ,   trust_remote_code=_lowercase      )
           # 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

from functools import lru_cache
from math import ceil

UpperCAmelCase__  			=				1_0_0

UpperCAmelCase__  			=				set(range(3, NUM_PRIMES, 2))
primes.add(2)
UpperCAmelCase__  			=				42

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
					if prime not in primes:
										continue
					primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))






@lru_cache(maxsize=100 )
def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: int ):






			"""simple docstring"""




			if number_to_partition < 0:
						return set()
			elif number_to_partition == 0:
						return {1}

			__A=	set()
			__A=	42
			__A=	42

			for prime in primes:
						if prime > number_to_partition:
									continue
						for sub in partition(number_to_partition - prime ):
									ret.add(sub * prime )

			return ret






def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: int = 5000 ):






			"""simple docstring"""




			for number_to_partition in range(1,_SCREAMING_SNAKE_CASE ):
						if len(partition(_SCREAMING_SNAKE_CASE ) ) > number_unique_partitions:
									return number_to_partition
			return None


if __name__ == "__main__":
					print(F"""{solution() = }""")



