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


a       :						Dict       		=		get_tests_dir('''fixtures''')




class 		a_    (			unittest.TestCase						):







    def   _snake_case       (      self      :							Tuple  )		->Optional[int]:






        '''simple docstring'''






        _UpperCAmelCase        = mock.Mock()
        _UpperCAmelCase        = 5_00
        _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   _snake_case       (      self      :							str  )		->Any:






        '''simple docstring'''






        _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						):







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






        '''simple docstring'''






        _UpperCAmelCase        = TOKEN
        HfFolder.save_token(__UpperCamelCase  )







    @classmethod
    def   _snake_case       (      cls      :							Union[str, Any]  )		->List[str]:






        '''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   _snake_case       (      self      :							Any  )		->Optional[int]:






        '''simple docstring'''






        _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   _snake_case       (      self      :							Optional[int]  )		->Dict:






        '''simple docstring'''






        _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   _snake_case       (      self      :							List[str]  )		->List[str]:






        '''simple docstring'''






        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"""  )

"""simple docstring"""



def 			_UpperCamelCase						(    _A   )     ->	int:





    """simple docstring"""

    if not isinstance(_A       ,   _A   ) or number < 0:
        raise ValueError("""Input must be a non-negative integer"""   )

    _UpperCAmelCase        = 0
    while number:
        # This way we arrive at next set bit (next 1) instead of looping
        # through each bit and checking for 1s hence the
        # loop won't run 32 times it will only run the number of `1` times
        number &= number - 1
        count += 1
    return count


if __name__ == "__main__":
 import doctest

 doctest.testmod()