






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


snake_case__      :	Optional[int]       	=      get_tests_dir("""fixtures""")


class 						_a       (  unittest.TestCase    ):






  """simple docstring"""





  def    _UpperCAmelCase     (     self )			-> Union[str, Any]:
     # A mock response for an HTTP head request to emulate server down
     UpperCamelCase_									=     mock.Mock()
     UpperCamelCase_									=     500
     UpperCamelCase_									=     {}
     UpperCamelCase_									=     HTTPError
     UpperCamelCase_									=     {}

     # Download this model to make sure it's in the cache.
     UpperCamelCase_									=     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=_UpperCAmelCase ) as mock_head:
        UpperCamelCase_									=     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 )			-> Union[str, Any]:
     # This test is for deprecated behavior and can be removed in v5
     UpperCamelCase_									=     WavaVecaFeatureExtractor.from_pretrained(
         'https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json' )




@is_staging_test
class 						_a       (  unittest.TestCase    ):






  """simple docstring"""





  @classmethod
  def    _UpperCAmelCase     (     cls )			-> Optional[Any]:
     UpperCamelCase_									=     TOKEN
     HfFolder.save_token(_UpperCAmelCase )




  @classmethod
  def    _UpperCAmelCase     (     cls )			-> Any:
     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 )			-> Dict:
     UpperCamelCase_									=     WavaVecaFeatureExtractor.from_pretrained(_UpperCAmelCase )
     feature_extractor.push_to_hub('test-feature-extractor'		,		use_auth_token=self._token )

     UpperCamelCase_									=     WavaVecaFeatureExtractor.from_pretrained(f"""{USER}/test-feature-extractor""" )
     for k, v in feature_extractor.__dict__.items():
        self.assertEqual(_UpperCAmelCase		,		getattr(_UpperCAmelCase		,		_UpperCAmelCase ) )

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

     UpperCamelCase_									=     WavaVecaFeatureExtractor.from_pretrained(f"""{USER}/test-feature-extractor""" )
     for k, v in feature_extractor.__dict__.items():
        self.assertEqual(_UpperCAmelCase		,		getattr(_UpperCAmelCase		,		_UpperCAmelCase ) )




  def    _UpperCAmelCase     (     self )			-> Optional[int]:
     UpperCamelCase_									=     WavaVecaFeatureExtractor.from_pretrained(_UpperCAmelCase )
     feature_extractor.push_to_hub('valid_org/test-feature-extractor'		,		use_auth_token=self._token )

     UpperCamelCase_									=     WavaVecaFeatureExtractor.from_pretrained('valid_org/test-feature-extractor' )
     for k, v in feature_extractor.__dict__.items():
        self.assertEqual(_UpperCAmelCase		,		getattr(_UpperCAmelCase		,		_UpperCAmelCase ) )

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

     UpperCamelCase_									=     WavaVecaFeatureExtractor.from_pretrained('valid_org/test-feature-extractor-org' )
     for k, v in feature_extractor.__dict__.items():
        self.assertEqual(_UpperCAmelCase		,		getattr(_UpperCAmelCase		,		_UpperCAmelCase ) )




  def    _UpperCAmelCase     (     self )			-> Optional[int]:
     CustomFeatureExtractor.register_for_auto_class()
     UpperCamelCase_									=     CustomFeatureExtractor.from_pretrained(_UpperCAmelCase )

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

     UpperCamelCase_									=     AutoFeatureExtractor.from_pretrained(
         f"""{USER}/test-dynamic-feature-extractor"""		,		trust_remote_code=_UpperCAmelCase )
     # 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' )













import os
from math import logaa






def     _snake_case    (__lowercase = "base_exp.txt"):
   UpperCamelCase_									=     0
   UpperCamelCase_									=     0
   for i, line in enumerate(open(os.path.join(os.path.dirname(__lowercase)    ,      __lowercase))):
      UpperCamelCase_		,      UpperCamelCase_									=     list(map(__lowercase    ,      line.split(',')))
      if x * logaa(__lowercase) > largest:
         UpperCamelCase_									=     x * logaa(__lowercase)
         UpperCamelCase_									=     i + 1
   return result


if __name__ == "__main__":
 print(solution())





