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


UpperCamelCase_       :    Optional[int]						      =			get_tests_dir('''fixtures''')



class __lowerCAmelCase					(       unittest.TestCase   ):




			"""simple docstring"""







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







								"""simple docstring"""
								# A mock response for an HTTP head request to emulate server down
								A_								=    mock.Mock()
								A_								=    500
								A_								=    {}
								A_								=    HTTPError
								A_								=    {}

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






			def   lowerCamelCase__  (					self    :       Dict						)   ->			Any:







								"""simple docstring"""
								# This test is for deprecated behavior and can be removed in v5
								A_								=    WavaVecaFeatureExtractor.from_pretrained(
								    "https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"						)





@is_staging_test
class __lowerCAmelCase					(       unittest.TestCase   ):




			"""simple docstring"""







			@classmethod
			def   lowerCamelCase__  (					cls    :       List[Any]						)   ->			List[str]:







								"""simple docstring"""
								A_								=    TOKEN
								HfFolder.save_token(_snake_case						)




			@classmethod
			def   lowerCamelCase__  (					cls    :       str						)   ->			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   lowerCamelCase__  (					self    :       Optional[int]						)   ->			Tuple:







								"""simple docstring"""
								A_								=    WavaVecaFeatureExtractor.from_pretrained(_snake_case						)
								feature_extractor.push_to_hub("test-feature-extractor"							, use_auth_token=self._token						)

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

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

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




			def   lowerCamelCase__  (					self    :       Any						)   ->			str:







								"""simple docstring"""
								A_								=    WavaVecaFeatureExtractor.from_pretrained(_snake_case						)
								feature_extractor.push_to_hub("valid_org/test-feature-extractor"							, use_auth_token=self._token						)

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

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

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






			def   lowerCamelCase__  (					self    :       Tuple						)   ->			List[str]:







								"""simple docstring"""
								CustomFeatureExtractor.register_for_auto_class()
								A_								=    CustomFeatureExtractor.from_pretrained(_snake_case						)

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

								A_								=    AutoFeatureExtractor.from_pretrained(
								    F'{USER}/test-dynamic-feature-extractor'							, trust_remote_code=_snake_case						)
								# 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 				A_  (__a					):

					'''simple docstring'''





					A_								=    len(__a					)
					while cur > 1:
										# Find the maximum number in arr
										A_								=    arr.index(max(arr[0:cur]					)					)
										# Reverse from 0 to mi
										A_								=    arr[mi::-1] + arr[mi + 1 : len(__a					)]
										# Reverse whole list
										A_								=    arr[cur - 1 :: -1] + arr[cur : len(__a					)]
										cur -= 1
					return arr


if __name__ == "__main__":
		UpperCamelCase_       :    Optional[Any]						      =			input('''Enter numbers separated by a comma:\n''').strip()
		UpperCamelCase_       :    Any						      =			[int(item) for item in user_input.split(''',''')]
		print(pancake_sort(unsorted))




