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


_lowercase          =						get_tests_dir("""fixtures""")




class     UpperCAmelCase_	(						unittest.TestCase					):






						'''simple docstring'''






						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					mock.Mock()
												_lowerCAmelCase    		=					500
												_lowerCAmelCase    		=					{}
												_lowerCAmelCase    		=					HTTPError
												_lowerCAmelCase    		=					{}

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




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					WavaVecaFeatureExtractor.from_pretrained(
												    """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json""" )






@is_staging_test
class     UpperCAmelCase_	(						unittest.TestCase					):






						'''simple docstring'''






						@classmethod
						def    _lowercase      (   cls ):

												"""simple docstring"""



												_lowerCAmelCase    		=					TOKEN
												HfFolder.save_token(_lowercase )




						@classmethod
						def    _lowercase      (   cls ):

												"""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    _lowercase      (   self ):

												"""simple docstring"""



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

												_lowerCAmelCase    		=					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 )

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




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					WavaVecaFeatureExtractor.from_pretrained(_lowercase )
												feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""       ,  use_auth_token=self._token )

												_lowerCAmelCase    		=					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 )

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




						def    _lowercase      (   self ):

												"""simple docstring"""



												CustomFeatureExtractor.register_for_auto_class()
												_lowerCAmelCase    		=					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"""}       ,  )

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







from timeit import timeit

_lowerCAmelCase				:   Tuple						       =						{
    '''MALAYALAM''': True,
    '''String''': False,
    '''rotor''': True,
    '''level''': True,
    '''A''': True,
    '''BB''': True,
    '''ABC''': False,
    '''amanaplanacanalpanama''': True,  # "a man a plan a canal panama"
}
# Ensure our test data is valid
assert all((key == key[::-1]) is value for key, value in test_data.items())

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   A_       :					List[str]        =      0
   A_       :					str        =      len(_lowerCAmelCase						) - 1
   while start_i < end_i:
      if s[start_i] == s[end_i]:
         start_i += 1
         end_i -= 1
      else:
         return False
   return True

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   A_       :					int        =      len(_lowerCAmelCase						) // 2
   A_       :					Union[str, Any]        =      len(_lowerCAmelCase						)

   # We need to traverse till half of the length of string
   # as we can get access of the i'th last element from
   # i'th index.
   # eg: [0,1,2,3,4,5] => 4th index can be accessed
   # with the help of 1st index (i==n-i-1)
   # where n is length of string
   return all(s[i] == s[n - i - 1] for i in range(_lowerCAmelCase						)						)

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   if len(_lowerCAmelCase						) <= 2:
      return True
   if s[0] == s[len(_lowerCAmelCase						) - 1]:
      return is_palindrome_recursive(s[1:-1]						)
   else:
      return False

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    bool:
   return s == s[::-1]

def   __snake_case    (       _lowerCAmelCase			:			str						)			->    None:
   A_       :					int        =      f"all({name}(key) is value for key, value in test_data.items())"
   A_       :					List[str]        =      f"from __main__ import test_data, {name}"
   A_       :					str        =      500000
   A_       :					List[str]        =      timeit(stmt=_lowerCAmelCase					,					setup=_lowerCAmelCase					,					number=_lowerCAmelCase						)
   print(f"{name:<35} finished {number:,} runs in {result:.5f} seconds"						)


if __name__ == "__main__":
 for key, value in test_data.items():
  assert is_palindrome(key) is is_palindrome_recursive(key)
  assert is_palindrome(key) is is_palindrome_slice(key)
  print(F'''{key:21} {value}''')
 print('''a man a plan a canal panama''')

 # finished 500,000 runs in 0.46793 seconds
 benchmark_function('''is_palindrome_slice''')
 # finished 500,000 runs in 0.85234 seconds
 benchmark_function('''is_palindrome''')
 # finished 500,000 runs in 1.32028 seconds
 benchmark_function('''is_palindrome_recursive''')
 # finished 500,000 runs in 2.08679 seconds
 benchmark_function('''is_palindrome_traversal''')
