import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from huggingface_hub import HfFolder, Repository, create_repo, delete_repo
from requests.exceptions import HTTPError

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


__lowerCamelCase					:	Optional[Any]       =  get_tests_dir('''fixtures/dummy_feature_extractor_config.json''')
__lowerCamelCase					:	int       =  get_tests_dir('''fixtures/vocab.json''')
__lowerCamelCase					:	Any       =  get_tests_dir('''fixtures''')






class 		a__						(					unittest.TestCase					):
					A	       =							['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']

					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    0

					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"    )
							self.assertIsInstance(_A,_A    )

					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							with tempfile.TemporaryDirectory() as tmpdirname:
									SCREAMING_SNAKE_CASE_  :		str				      =    WavaVecaConfig()
									SCREAMING_SNAKE_CASE_  :		str				      =    AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"    )

									# save in new folder
									model_config.save_pretrained(_A    )
									processor.save_pretrained(_A    )

									SCREAMING_SNAKE_CASE_  :		List[Any]				      =    AutoProcessor.from_pretrained(_A    )

							self.assertIsInstance(_A,_A    )

					def 				__UpperCamelCase   (    self      :       str    ):







							"""simple docstring"""






							with tempfile.TemporaryDirectory() as tmpdirname:
									# copy relevant files
									copyfile(_A,os.path.join(_A,_A    )    )
									copyfile(_A,os.path.join(_A,"vocab.json"    )    )

									SCREAMING_SNAKE_CASE_  :		str				      =    AutoProcessor.from_pretrained(_A    )

							self.assertIsInstance(_A,_A    )

					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							with tempfile.TemporaryDirectory() as tmpdirname:
									SCREAMING_SNAKE_CASE_  :		List[str]				      =    WavaVecaFeatureExtractor()
									SCREAMING_SNAKE_CASE_  :		List[Any]				      =    AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"    )

									SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    WavaVecaProcessor(_A,_A    )

									# save in new folder
									processor.save_pretrained(_A    )

									# drop `processor_class` in tokenizer
									with open(os.path.join(_A,_A    ),"r"    ) as f:
											SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    json.load(_A    )
											config_dict.pop("processor_class"    )

									with open(os.path.join(_A,_A    ),"w"    ) as f:
											f.write(json.dumps(_A    )    )

									SCREAMING_SNAKE_CASE_  :		List[Any]				      =    AutoProcessor.from_pretrained(_A    )

							self.assertIsInstance(_A,_A    )

					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							with tempfile.TemporaryDirectory() as tmpdirname:
									SCREAMING_SNAKE_CASE_  :		Dict				      =    WavaVecaFeatureExtractor()
									SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"    )

									SCREAMING_SNAKE_CASE_  :		List[Any]				      =    WavaVecaProcessor(_A,_A    )

									# save in new folder
									processor.save_pretrained(_A    )

									# drop `processor_class` in feature extractor
									with open(os.path.join(_A,_A    ),"r"    ) as f:
											SCREAMING_SNAKE_CASE_  :		Dict				      =    json.load(_A    )
											config_dict.pop("processor_class"    )

									with open(os.path.join(_A,_A    ),"w"    ) as f:
											f.write(json.dumps(_A    )    )

									SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    AutoProcessor.from_pretrained(_A    )

							self.assertIsInstance(_A,_A    )

					def 				__UpperCamelCase   (    self      :       str    ):







							"""simple docstring"""






							with tempfile.TemporaryDirectory() as tmpdirname:
									SCREAMING_SNAKE_CASE_  :		Tuple				      =    WavaVecaConfig(processor_class="Wav2Vec2Processor"    )
									model_config.save_pretrained(_A    )
									# copy relevant files
									copyfile(_A,os.path.join(_A,"vocab.json"    )    )
									# create emtpy sample processor
									with open(os.path.join(_A,_A    ),"w"    ) as f:
											f.write("{}"    )

									SCREAMING_SNAKE_CASE_  :		List[str]				      =    AutoProcessor.from_pretrained(_A    )

							self.assertIsInstance(_A,_A    )

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							with self.assertRaises(_A    ):
									SCREAMING_SNAKE_CASE_  :		int				      =    AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"    )
							# If remote code is disabled, we can't load this config.
							with self.assertRaises(_A    ):
									SCREAMING_SNAKE_CASE_  :		Dict				      =    AutoProcessor.from_pretrained(
									    "hf-internal-testing/test_dynamic_processor",trust_remote_code=_A    )

							SCREAMING_SNAKE_CASE_  :		Dict				      =    AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor",trust_remote_code=_A    )
							self.assertTrue(processor.special_attribute_present    )
							self.assertEqual(processor.__class__.__name__,"NewProcessor"    )

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    processor.feature_extractor
							self.assertTrue(feature_extractor.special_attribute_present    )
							self.assertEqual(feature_extractor.__class__.__name__,"NewFeatureExtractor"    )

							SCREAMING_SNAKE_CASE_  :		int				      =    processor.tokenizer
							self.assertTrue(tokenizer.special_attribute_present    )
							if is_tokenizers_available():
									self.assertEqual(tokenizer.__class__.__name__,"NewTokenizerFast"    )

									# Test we can also load the slow version
									SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    AutoProcessor.from_pretrained(
									    "hf-internal-testing/test_dynamic_processor",trust_remote_code=_A,use_fast=_A    )
									SCREAMING_SNAKE_CASE_  :		List[str]				      =    new_processor.tokenizer
									self.assertTrue(new_tokenizer.special_attribute_present    )
									self.assertEqual(new_tokenizer.__class__.__name__,"NewTokenizer"    )
							else:
									self.assertEqual(tokenizer.__class__.__name__,"NewTokenizer"    )

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							try:
									AutoConfig.register("custom",_A    )
									AutoFeatureExtractor.register(_A,_A    )
									AutoTokenizer.register(_A,slow_tokenizer_class=_A    )
									AutoProcessor.register(_A,_A    )
									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(_A    ):
											AutoProcessor.register(_A,_A    )

									# Now that the config is registered, it can be used as any other config with the auto-API
									SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    CustomFeatureExtractor.from_pretrained(_A    )

									with tempfile.TemporaryDirectory() as tmp_dir:
											SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    os.path.join(_A,"vocab.txt"    )
											with open(_A,"w",encoding="utf-8"    ) as vocab_writer:
													vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]    )    )
											SCREAMING_SNAKE_CASE_  :		str				      =    CustomTokenizer(_A    )

									SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    CustomProcessor(_A,_A    )

									with tempfile.TemporaryDirectory() as tmp_dir:
											processor.save_pretrained(_A    )
											SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    AutoProcessor.from_pretrained(_A    )
											self.assertIsInstance(_A,_A    )

							finally:
									if "custom" in CONFIG_MAPPING._extra_content:
											del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
											del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
									if CustomConfig in TOKENIZER_MAPPING._extra_content:
											del TOKENIZER_MAPPING._extra_content[CustomConfig]
									if CustomConfig in PROCESSOR_MAPPING._extra_content:
											del PROCESSOR_MAPPING._extra_content[CustomConfig]

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							class 		a__						(					A__					):
												A	       =							False







							class 		a__						(					A__					):
												A	       =							False







							class 		a__						(					A__					):
												A	       =							'AutoFeatureExtractor'
												A	       =							'AutoTokenizer'
												A	       =							False

							try:
									AutoConfig.register("custom",_A    )
									AutoFeatureExtractor.register(_A,_A    )
									AutoTokenizer.register(_A,slow_tokenizer_class=_A    )
									AutoProcessor.register(_A,_A    )
									# If remote code is not set, the default is to use local classes.
									SCREAMING_SNAKE_CASE_  :		int				      =    AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"    )
									self.assertEqual(processor.__class__.__name__,"NewProcessor"    )
									self.assertFalse(processor.special_attribute_present    )
									self.assertFalse(processor.feature_extractor.special_attribute_present    )
									self.assertFalse(processor.tokenizer.special_attribute_present    )

									# If remote code is disabled, we load the local ones.
									SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    AutoProcessor.from_pretrained(
									    "hf-internal-testing/test_dynamic_processor",trust_remote_code=_A    )
									self.assertEqual(processor.__class__.__name__,"NewProcessor"    )
									self.assertFalse(processor.special_attribute_present    )
									self.assertFalse(processor.feature_extractor.special_attribute_present    )
									self.assertFalse(processor.tokenizer.special_attribute_present    )

									# If remote is enabled, we load from the Hub.
									SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    AutoProcessor.from_pretrained(
									    "hf-internal-testing/test_dynamic_processor",trust_remote_code=_A    )
									self.assertEqual(processor.__class__.__name__,"NewProcessor"    )
									self.assertTrue(processor.special_attribute_present    )
									self.assertTrue(processor.feature_extractor.special_attribute_present    )
									self.assertTrue(processor.tokenizer.special_attribute_present    )

							finally:
									if "custom" in CONFIG_MAPPING._extra_content:
											del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
											del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
									if CustomConfig in TOKENIZER_MAPPING._extra_content:
											del TOKENIZER_MAPPING._extra_content[CustomConfig]
									if CustomConfig in PROCESSOR_MAPPING._extra_content:
											del PROCESSOR_MAPPING._extra_content[CustomConfig]

					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Any				      =    AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-bert"    )
							self.assertEqual(processor.__class__.__name__,"BertTokenizerFast"    )






					def 				__UpperCamelCase   (    self      :       Optional[int]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Any				      =    AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-convnext"    )
							self.assertEqual(processor.__class__.__name__,"ConvNextImageProcessor"    )







@is_staging_test
class 		a__						(					unittest.TestCase					):
					A	       =							['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']

					@classmethod
					def 				__UpperCamelCase   (    cls      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    TOKEN
							HfFolder.save_token(_A    )

					@classmethod
					def 				__UpperCamelCase   (    cls      :       Union[str, Any]    ):







							"""simple docstring"""






							try:
									delete_repo(token=cls._token,repo_id="test-processor"    )
							except HTTPError:
									pass

							try:
									delete_repo(token=cls._token,repo_id="valid_org/test-processor-org"    )
							except HTTPError:
									pass

							try:
									delete_repo(token=cls._token,repo_id="test-dynamic-processor"    )
							except HTTPError:
									pass

					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    WavaVecaProcessor.from_pretrained(_A    )
							with tempfile.TemporaryDirectory() as tmp_dir:
									processor.save_pretrained(
									    os.path.join(_A,"test-processor"    ),push_to_hub=_A,use_auth_token=self._token    )

									SCREAMING_SNAKE_CASE_  :		List[str]				      =    WavaVecaProcessor.from_pretrained(F'{USER}/test-processor'    )
									for k, v in processor.feature_extractor.__dict__.items():
											self.assertEqual(_A,getattr(new_processor.feature_extractor,_A    )    )
									self.assertDictEqual(new_processor.tokenizer.get_vocab(),processor.tokenizer.get_vocab()    )

					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Dict				      =    WavaVecaProcessor.from_pretrained(_A    )

							with tempfile.TemporaryDirectory() as tmp_dir:
									processor.save_pretrained(
									    os.path.join(_A,"test-processor-org"    ),push_to_hub=_A,use_auth_token=self._token,organization="valid_org",)

									SCREAMING_SNAKE_CASE_  :		List[Any]				      =    WavaVecaProcessor.from_pretrained("valid_org/test-processor-org"    )
									for k, v in processor.feature_extractor.__dict__.items():
											self.assertEqual(_A,getattr(new_processor.feature_extractor,_A    )    )
									self.assertDictEqual(new_processor.tokenizer.get_vocab(),processor.tokenizer.get_vocab()    )






					def 				__UpperCamelCase   (    self      :       str    ):







							"""simple docstring"""






							CustomFeatureExtractor.register_for_auto_class()
							CustomTokenizer.register_for_auto_class()
							CustomProcessor.register_for_auto_class()

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    CustomFeatureExtractor.from_pretrained(_A    )

							with tempfile.TemporaryDirectory() as tmp_dir:
									SCREAMING_SNAKE_CASE_  :		List[Any]				      =    os.path.join(_A,"vocab.txt"    )
									with open(_A,"w",encoding="utf-8"    ) as vocab_writer:
											vocab_writer.write("".join([x + "\n" for x in self.vocab_tokens]    )    )
									SCREAMING_SNAKE_CASE_  :		str				      =    CustomTokenizer(_A    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    CustomProcessor(_A,_A    )

							with tempfile.TemporaryDirectory() as tmp_dir:
									create_repo(F'{USER}/test-dynamic-processor',token=self._token    )
									SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    Repository(_A,clone_from=F'{USER}/test-dynamic-processor',token=self._token    )
									processor.save_pretrained(_A    )

									# This has added the proper auto_map field to the feature extractor config
									self.assertDictEqual(
									    processor.feature_extractor.auto_map,{
									        "AutoFeatureExtractor": "custom_feature_extraction.CustomFeatureExtractor",
									        "AutoProcessor": "custom_processing.CustomProcessor",
									    },)

									# This has added the proper auto_map field to the tokenizer config
									with open(os.path.join(_A,"tokenizer_config.json"    )    ) as f:
											SCREAMING_SNAKE_CASE_  :		Dict				      =    json.load(_A    )
									self.assertDictEqual(
									    tokenizer_config["auto_map"],{
									        "AutoTokenizer": ["custom_tokenization.CustomTokenizer", None],
									        "AutoProcessor": "custom_processing.CustomProcessor",
									    },)

									# The code has been copied from fixtures
									self.assertTrue(os.path.isfile(os.path.join(_A,"custom_feature_extraction.py"    )    )    )
									self.assertTrue(os.path.isfile(os.path.join(_A,"custom_tokenization.py"    )    )    )
									self.assertTrue(os.path.isfile(os.path.join(_A,"custom_processing.py"    )    )    )

									repo.push_to_hub()

							SCREAMING_SNAKE_CASE_  :		int				      =    AutoProcessor.from_pretrained(F'{USER}/test-dynamic-processor',trust_remote_code=_A    )
							# Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
							self.assertEqual(new_processor.__class__.__name__,"CustomProcessor"    )

def       _snake_case	(   lowerCAmelCase							:   list	):
		"""simple docstring"""







		SCREAMING_SNAKE_CASE_  :		Dict				      =    len(lowerCAmelCase	)
		for i in range(1   , lowerCAmelCase	):
				SCREAMING_SNAKE_CASE_  :		int				      =    collection[i]
				SCREAMING_SNAKE_CASE_  :		Any				      =    0
				SCREAMING_SNAKE_CASE_  :		Tuple				      =    i - 1

				while low <= high:
						SCREAMING_SNAKE_CASE_  :		int				      =    (low + high) // 2
						if val < collection[mid]:
								SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    mid - 1
						else:
								SCREAMING_SNAKE_CASE_  :		Tuple				      =    mid + 1
				for j in range(lowerCAmelCase   , lowerCAmelCase   , -1	):
						SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    collection[j - 1]
				SCREAMING_SNAKE_CASE_  :		int				      =    val
		return collection


if __name__ == "__main__":
		__lowerCamelCase					:	Dict       =  input('''Enter numbers separated by a comma:\n''').strip()
		__lowerCamelCase					:	List[str]       =  [int(item) for item in user_input.split(''',''')]
		print(binary_insertion_sort(unsorted))
