

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


lowerCAmelCase__						:       Tuple										=						get_tests_dir("""fixtures""")




class     a			(				unittest.TestCase       ):






						"""simple docstring"""




						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  mock.Mock()
								snake_case__						:       str       						=  5_0_0
								snake_case__						:       int       						=  {}
								snake_case__						:       List[Any]       						=  HTTPError
								snake_case__						:       List[str]       						=  {}

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







						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  ViTImageProcessor.from_pretrained(
								    '''https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'''  )







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								with self.assertRaises(snake_case_  ):
										# config is in subfolder, the following should not work without specifying the subfolder
										snake_case__						:       List[str]       						=  AutoImageProcessor.from_pretrained('''hf-internal-testing/stable-diffusion-all-variants'''  )

								snake_case__						:       List[Any]       						=  AutoImageProcessor.from_pretrained(
								    '''hf-internal-testing/stable-diffusion-all-variants'''			,			subfolder='''feature_extractor'''  )

								self.assertIsNotNone(snake_case_  )





@is_staging_test
class     a			(				unittest.TestCase       ):






						"""simple docstring"""




						@classmethod
						def       __magic_name__							(							cls					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  TOKEN
								HfFolder.save_token(snake_case_  )







						@classmethod
						def       __magic_name__							(							cls					:      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       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  ViTImageProcessor.from_pretrained(snake_case_  )
								image_processor.push_to_hub('''test-image-processor'''			,			use_auth_token=self._token  )

								snake_case__						:       Optional[Any]       						=  ViTImageProcessor.from_pretrained(F"""{USER}/test-image-processor"""  )
								for k, v in image_processor.__dict__.items():
										self.assertEqual(snake_case_			,			getattr(snake_case_			,			snake_case_  )  )

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

								snake_case__						:       str       						=  ViTImageProcessor.from_pretrained(F"""{USER}/test-image-processor"""  )
								for k, v in image_processor.__dict__.items():
										self.assertEqual(snake_case_			,			getattr(snake_case_			,			snake_case_  )  )







						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  ViTImageProcessor.from_pretrained(snake_case_  )
								image_processor.push_to_hub('''valid_org/test-image-processor'''			,			use_auth_token=self._token  )

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

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

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







						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								CustomImageProcessor.register_for_auto_class()
								snake_case__						:       List[str]       						=  CustomImageProcessor.from_pretrained(snake_case_  )

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

								snake_case__						:       List[str]       						=  AutoImageProcessor.from_pretrained(
								    F"""{USER}/test-dynamic-image-processor"""			,			trust_remote_code=snake_case_  )
								# 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 collections.abc import Sequence




def 	_a       (				__lowerCAmelCase		:      Sequence[int] | None = None     ):

		"""simple docstring"""

		if nums is None or not nums:
				raise ValueError('''Input sequence should not be empty'''     )

		snake_case__						:       Optional[Any]       						=  nums[0]
		for i in range(1   ,							len(__lowerCAmelCase     )     ):
				snake_case__						:       Tuple       						=  nums[i]
				snake_case__						:       Optional[int]       						=  max(__lowerCAmelCase   ,							ans + num   ,							__lowerCAmelCase     )

		return ans


if __name__ == "__main__":
					import doctest

					doctest.testmod()

					# Try on a sample input from the user
					lowerCAmelCase__						:       str										=						int(input("""Enter number of elements : """).strip())
					lowerCAmelCase__						:       Dict										=						list(map(int, input("""\nEnter the numbers : """).strip().split()))[:n]
					print(max_subsequence_sum(array))



