



"""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 AutoFeatureExtractor, WavaVecaFeatureExtractor
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_feature_extraction import CustomFeatureExtractor  # noqa E402


__lowerCAmelCase							:       int          =       get_tests_dir('''fixtures''')



class  _lowerCAmelCase     (					unittest.TestCase		):





		"""simple docstring"""






		def  UpperCAmelCase__				(       self )			->    List[str]:







								'''simple docstring'''

								snake_case_ :			List[str]            =      mock.Mock()
								snake_case_ :			Dict            =      5_0_0
								snake_case_ :			List[str]            =      {}
								snake_case_ :			Optional[int]            =      HTTPError
								snake_case_ :			Union[str, Any]            =      {}

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





		def  UpperCAmelCase__				(       self )			->    int:







								'''simple docstring'''

								snake_case_ :			List[str]            =      WavaVecaFeatureExtractor.from_pretrained(
								    """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json""" )




@is_staging_test
class  _lowerCAmelCase     (					unittest.TestCase		):





		"""simple docstring"""






		@classmethod
		def  UpperCAmelCase__				(       cls )			->    Dict:







								'''simple docstring'''

								snake_case_ :			List[Any]            =      TOKEN
								HfFolder.save_token(_lowercase )





		@classmethod
		def  UpperCAmelCase__				(       cls )			->    int:







								'''simple docstring'''

								try:
														delete_repo(token=cls._token				,     repo_id="""test-feature-extractor""" )
								except HTTPError:
														pass

								try:
														delete_repo(token=cls._token				,     repo_id="""valid_org/test-feature-extractor-org""" )
								except HTTPError:
														pass

								try:
														delete_repo(token=cls._token				,     repo_id="""test-dynamic-feature-extractor""" )
								except HTTPError:
														pass





		def  UpperCAmelCase__				(       self )			->    Union[str, Any]:







								'''simple docstring'''

								snake_case_ :			int            =      WavaVecaFeatureExtractor.from_pretrained(_lowercase )
								feature_extractor.push_to_hub("""test-feature-extractor"""				,     use_auth_token=self._token )

								snake_case_ :			Dict            =      WavaVecaFeatureExtractor.from_pretrained(f'{USER}/test-feature-extractor' )
								for k, v in feature_extractor.__dict__.items():
														self.assertEqual(_lowercase				,     getattr(_lowercase				,     _lowercase ) )

								# Reset repo
								delete_repo(token=self._token				,     repo_id="""test-feature-extractor""" )

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
														feature_extractor.save_pretrained(
														    _lowercase				,     repo_id="""test-feature-extractor"""				,     push_to_hub=_lowercase				,     use_auth_token=self._token )

								snake_case_ :			Union[str, Any]            =      WavaVecaFeatureExtractor.from_pretrained(f'{USER}/test-feature-extractor' )
								for k, v in feature_extractor.__dict__.items():
														self.assertEqual(_lowercase				,     getattr(_lowercase				,     _lowercase ) )





		def  UpperCAmelCase__				(       self )			->    Optional[int]:







								'''simple docstring'''

								snake_case_ :			Optional[Any]            =      WavaVecaFeatureExtractor.from_pretrained(_lowercase )
								feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""				,     use_auth_token=self._token )

								snake_case_ :			Optional[Any]            =      WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor""" )
								for k, v in feature_extractor.__dict__.items():
														self.assertEqual(_lowercase				,     getattr(_lowercase				,     _lowercase ) )

								# Reset repo
								delete_repo(token=self._token				,     repo_id="""valid_org/test-feature-extractor""" )

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
														feature_extractor.save_pretrained(
														    _lowercase				,     repo_id="""valid_org/test-feature-extractor-org"""				,     push_to_hub=_lowercase				,     use_auth_token=self._token )

								snake_case_ :			Any            =      WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org""" )
								for k, v in feature_extractor.__dict__.items():
														self.assertEqual(_lowercase				,     getattr(_lowercase				,     _lowercase ) )





		def  UpperCAmelCase__				(       self )			->    Any:







								'''simple docstring'''

								CustomFeatureExtractor.register_for_auto_class()
								snake_case_ :			List[Any]            =      CustomFeatureExtractor.from_pretrained(_lowercase )

								feature_extractor.push_to_hub("""test-dynamic-feature-extractor"""				,     use_auth_token=self._token )

								# This has added the proper auto_map field to the config
								self.assertDictEqual(
								    feature_extractor.auto_map				,     {"""AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor"""}				,     )

								snake_case_ :			Tuple            =      AutoFeatureExtractor.from_pretrained(
								    f'{USER}/test-dynamic-feature-extractor'				,     trust_remote_code=_lowercase )
								# Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
								self.assertEqual(new_feature_extractor.__class__.__name__				,     """CustomFeatureExtractor""" )




'''simple docstring'''

from math import factorial




def 							_UpperCamelCase				(   lowerCAmelCase__:					int = 100   )      -> int:
							return sum(map(lowerCAmelCase__		,str(factorial(lowerCAmelCase__   )   )   )   )


if __name__ == "__main__":
							print(solution(int(input("Enter the Number: ").strip())))





