



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


a__    =	get_tests_dir("""fixtures""")







class 		snake_case						(	unittest.TestCase  ):



   '''simple docstring'''






   def      UpperCamelCase_  (					self							:			Dict)				->				int:

    """simple docstring"""







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

    # Download this model to make sure it's in the cache.
    _snake_case    :  Tuple					=					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=lowerCAmelCase) as mock_head:
     _snake_case    :  Tuple					=					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							:			str)				->				int:

    """simple docstring"""







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







@is_staging_test
class 		snake_case						(	unittest.TestCase  ):



   '''simple docstring'''






   @classmethod
   def      UpperCamelCase_  (					cls							:			Tuple)				->				Union[str, Any]:

    """simple docstring"""







    _snake_case    :  str					=					TOKEN
    HfFolder.save_token(lowerCAmelCase)

   @classmethod
   def      UpperCamelCase_  (					cls							:			str)				->				Any:

    """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							:			Any)				->				int:

    """simple docstring"""







    _snake_case    :  str					=					WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase)
    feature_extractor.push_to_hub("""test-feature-extractor"""				,		use_auth_token=self._token)

    _snake_case    :  List[Any]					=					WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor''')
    for k, v in feature_extractor.__dict__.items():
     self.assertEqual(lowerCAmelCase				,		getattr(lowerCAmelCase				,		lowerCAmelCase))

    # 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(
         lowerCAmelCase				,		repo_id="""test-feature-extractor"""				,		push_to_hub=lowerCAmelCase				,		use_auth_token=self._token)

    _snake_case    :  Optional[Any]					=					WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor''')
    for k, v in feature_extractor.__dict__.items():
     self.assertEqual(lowerCAmelCase				,		getattr(lowerCAmelCase				,		lowerCAmelCase))

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

    """simple docstring"""







    _snake_case    :  Dict					=					WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase)
    feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""				,		use_auth_token=self._token)

    _snake_case    :  str					=					WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor""")
    for k, v in feature_extractor.__dict__.items():
     self.assertEqual(lowerCAmelCase				,		getattr(lowerCAmelCase				,		lowerCAmelCase))

    # 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(
         lowerCAmelCase				,		repo_id="""valid_org/test-feature-extractor-org"""				,		push_to_hub=lowerCAmelCase				,		use_auth_token=self._token)

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


   def      UpperCamelCase_  (					self							:			Tuple)				->				Dict:

    """simple docstring"""







    CustomFeatureExtractor.register_for_auto_class()
    _snake_case    :  Tuple					=					CustomFeatureExtractor.from_pretrained(lowerCAmelCase)

    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    :  Optional[Any]					=					AutoFeatureExtractor.from_pretrained(
        F'''{USER}/test-dynamic-feature-extractor'''				,		trust_remote_code=lowerCAmelCase)
    # 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""")





def       lowercase       (   SCREAMING_SNAKE_CASE__       :	int = 1_000				)  ->     int:
 _snake_case	,    _snake_case    :  str					=					1, 1
 _snake_case    :  List[Any]					=					2
 while True:
  _snake_case    :  Union[str, Any]					=					0
  _snake_case    :  int					=					fa + fa
  _snake_case	,    _snake_case    :  Union[str, Any]					=					fa, f
  index += 1
  for _ in str(SCREAMING_SNAKE_CASE__				):
   i += 1
  if i == n:
   break
 return index


if __name__ == "__main__":
  print(solution(int(str(input()).strip())))
