


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		       =							get_tests_dir('''fixtures''')





class   __a			(    unittest.TestCase      ):
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[Any]:




        '''simple docstring'''
        # A mock response for an HTTP head request to emulate server down
        lowercase__:   Tuple  			=   mock.Mock()
        lowercase__:   List[str]  			=   500
        lowercase__:   Optional[Any]  			=   {}
        lowercase__:   Any  			=   HTTPError
        lowercase__:   List[Any]  			=   {}

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




        '''simple docstring'''
        # This test is for deprecated behavior and can be removed in v5
        lowercase__:   Any  			=   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 		SCREAMING_SNAKE_CASE__   (   cls )					->				int:




        '''simple docstring'''
        lowercase__:   Any  			=   TOKEN
        HfFolder.save_token(lowerCAmelCase__ )
 @classmethod
 def 		SCREAMING_SNAKE_CASE__   (   cls )					->				List[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 		SCREAMING_SNAKE_CASE__   (   self )					->				int:




        '''simple docstring'''
        lowercase__:   Any  			=   WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase__ )
        feature_extractor.push_to_hub('test-feature-extractor'				, use_auth_token=self._token )

        lowercase__:   Optional[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 )

        lowercase__:   Union[str, Any]  			=   WavaVecaFeatureExtractor.from_pretrained(F'{USER}/test-feature-extractor' )
        for k, v in feature_extractor.__dict__.items():
               self.assertEqual(lowerCAmelCase__				, getattr(lowerCAmelCase__				, lowerCAmelCase__ ) )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[int]:




        '''simple docstring'''
        lowercase__:   Tuple  			=   WavaVecaFeatureExtractor.from_pretrained(lowerCAmelCase__ )
        feature_extractor.push_to_hub('valid_org/test-feature-extractor'				, use_auth_token=self._token )

        lowercase__:   Tuple  			=   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 )

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




        '''simple docstring'''
        CustomFeatureExtractor.register_for_auto_class()
        lowercase__:   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'}				, )

        lowercase__:   Optional[int]  			=   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' )






from __future__ import annotations




def    snake_case_     (  snake_case			,							snake_case     )  ->				list[int]:
       lowercase__:   List[str]  			=   0
       lowercase__:   Dict  			=   len(snake_case     ) - 1

       while i < j:
              if nums[i] + nums[j] == target:
                     return [i, j]
              elif nums[i] + nums[j] < target:
                     lowercase__:   Dict  			=   i + 1
              else:
                     lowercase__:   List[Any]  			=   j - 1

       return []


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F'''{two_pointer([2, 7, 11, 15], 9) = }''')


