

def        __UpperCamelCase     (      _A					:							list		)				->list:



							"""simple docstring"""

							for insert_index, insert_value in enumerate(collection[1:]		):
														lowerCamelCase_								=insert_index
														while insert_index >= 0 and insert_value < collection[insert_index]:
																					lowerCamelCase_								=collection[insert_index]
																					insert_index -= 1
														if insert_index != temp_index:
																					lowerCamelCase_								=insert_value
							return collection


if __name__ == "__main__":
	from doctest import testmod

	testmod()

	__A	:   List[str]	=					input('Enter numbers separated by a comma:\n').strip()
	__A	:   List[str]	=					[int(item) for item in user_input.split(',')]
	print(F"""{insertion_sort(unsorted) = }""")



import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
	from transformers.pipelines.conversational import Conversation

__A	:   Any	=					logging.get_logger(__name__)

__A	:   Union[str, Any]	=					{
    'vocab_file': 'vocab.json',
    'merges_file': 'merges.txt',
}

__A	:   Optional[int]	=					{
    'vocab_file': {
        'gpt2': 'https://huggingface.co/gpt2/resolve/main/vocab.json',
        'gpt2-medium': 'https://huggingface.co/gpt2-medium/resolve/main/vocab.json',
        'gpt2-large': 'https://huggingface.co/gpt2-large/resolve/main/vocab.json',
        'gpt2-xl': 'https://huggingface.co/gpt2-xl/resolve/main/vocab.json',
        'distilgpt2': 'https://huggingface.co/distilgpt2/resolve/main/vocab.json',
    },
    'merges_file': {
        'gpt2': 'https://huggingface.co/gpt2/resolve/main/merges.txt',
        'gpt2-medium': 'https://huggingface.co/gpt2-medium/resolve/main/merges.txt',
        'gpt2-large': 'https://huggingface.co/gpt2-large/resolve/main/merges.txt',
        'gpt2-xl': 'https://huggingface.co/gpt2-xl/resolve/main/merges.txt',
        'distilgpt2': 'https://huggingface.co/distilgpt2/resolve/main/merges.txt',
    },
}

__A	:   Optional[Any]	=					{
    'gpt2': 10_24,
    'gpt2-medium': 10_24,
    'gpt2-large': 10_24,
    'gpt2-xl': 10_24,
    'distilgpt2': 10_24,
}




@lru_cache()
def        __UpperCamelCase     (      )				->int:



							"""simple docstring"""
							lowerCamelCase_								=(
							    list(range(ord("""!"""		)      ,  ord("""~"""		) + 1		)		) + list(range(ord("""¡"""		)      ,  ord("""¬"""		) + 1		)		) + list(range(ord("""®"""		)      ,  ord("""ÿ"""		) + 1		)		)
							)
							lowerCamelCase_								=bs[:]
							lowerCamelCase_								=0
							for b in range(2**8		):
														if b not in bs:
																					bs.append(_A		)
																					cs.append(2**8 + n		)
																					n += 1
							lowerCamelCase_								=[chr(_A		) for n in cs]
							return dict(zip(_A      ,  _A		)		)




def        __UpperCamelCase     (      _A					:							Optional[int]		)				->Optional[int]:



							"""simple docstring"""
							lowerCamelCase_								=set()
							lowerCamelCase_								=word[0]
							for char in word[1:]:
														pairs.add((prev_char, char)		)
														lowerCamelCase_								=char
							return pairs






class 			_SCREAMING_SNAKE_CASE      (  lowerCAmelCase__):
						_UpperCamelCase:Any	=		VOCAB_FILES_NAMES
						_UpperCamelCase:Any	=		PRETRAINED_VOCAB_FILES_MAP
						_UpperCamelCase:Optional[int]	=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						_UpperCamelCase:List[str]	=		["input_ids", "attention_mask"]







						def __init__(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE="replace"     ,						_SCREAMING_SNAKE_CASE="<|endoftext|>"     ,						_SCREAMING_SNAKE_CASE="<|endoftext|>"     ,						_SCREAMING_SNAKE_CASE="<|endoftext|>"     ,						_SCREAMING_SNAKE_CASE=None     ,						_SCREAMING_SNAKE_CASE=False     ,						_SCREAMING_SNAKE_CASE=False     ,						**_SCREAMING_SNAKE_CASE     ,						)->							Optional[Any]:
													lowerCamelCase_								=AddedToken(_SCREAMING_SNAKE_CASE     ,						lstrip=_SCREAMING_SNAKE_CASE     ,						rstrip=_SCREAMING_SNAKE_CASE							) if isinstance(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							) else bos_token
													lowerCamelCase_								=AddedToken(_SCREAMING_SNAKE_CASE     ,						lstrip=_SCREAMING_SNAKE_CASE     ,						rstrip=_SCREAMING_SNAKE_CASE							) if isinstance(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							) else eos_token
													lowerCamelCase_								=AddedToken(_SCREAMING_SNAKE_CASE     ,						lstrip=_SCREAMING_SNAKE_CASE     ,						rstrip=_SCREAMING_SNAKE_CASE							) if isinstance(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							) else unk_token
													lowerCamelCase_								=AddedToken(_SCREAMING_SNAKE_CASE     ,						lstrip=_SCREAMING_SNAKE_CASE     ,						rstrip=_SCREAMING_SNAKE_CASE							) if isinstance(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							) else pad_token
													super().__init__(
													    errors=_SCREAMING_SNAKE_CASE     ,						unk_token=_SCREAMING_SNAKE_CASE     ,						bos_token=_SCREAMING_SNAKE_CASE     ,						eos_token=_SCREAMING_SNAKE_CASE     ,						pad_token=_SCREAMING_SNAKE_CASE     ,						add_prefix_space=_SCREAMING_SNAKE_CASE     ,						add_bos_token=_SCREAMING_SNAKE_CASE     ,						**_SCREAMING_SNAKE_CASE     ,						)
													lowerCamelCase_								=add_bos_token

													with open(_SCREAMING_SNAKE_CASE     ,						encoding="""utf-8"""							) as vocab_handle:
																				lowerCamelCase_								=json.load(_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								={v: k for k, v in self.encoder.items()}
													lowerCamelCase_								=errors  # how to handle errors in decoding
													lowerCamelCase_								=bytes_to_unicode()
													lowerCamelCase_								={v: k for k, v in self.byte_encoder.items()}
													with open(_SCREAMING_SNAKE_CASE     ,						encoding="""utf-8"""							) as merges_handle:
																				lowerCamelCase_								=merges_handle.read().split("""\n"""							)[1:-1]
													lowerCamelCase_								=[tuple(merge.split()							) for merge in bpe_merges]
													lowerCamelCase_								=dict(zip(_SCREAMING_SNAKE_CASE     ,						range(len(_SCREAMING_SNAKE_CASE							)							)							)							)
													lowerCamelCase_								={}
													lowerCamelCase_								=add_prefix_space

													# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
													lowerCamelCase_								=re.compile(R"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""							)







						@property
						def        _snake_case				(			self							)->							str:
													return len(self.encoder							)







						def        _snake_case				(			self							)->							Optional[Any]:
													return dict(self.encoder     ,						**self.added_tokens_encoder							)







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE							)->							int:
													if token in self.cache:
																				return self.cache[token]
													lowerCamelCase_								=tuple(_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=get_pairs(_SCREAMING_SNAKE_CASE							)

													if not pairs:
																				return token

													while True:
																				lowerCamelCase_								=min(_SCREAMING_SNAKE_CASE     ,						key=lambda _SCREAMING_SNAKE_CASE							: self.bpe_ranks.get(_SCREAMING_SNAKE_CASE     ,						float("""inf"""							)							)							)
																				if bigram not in self.bpe_ranks:
																											break
																				lowerCamelCase_	,   lowerCamelCase_								=bigram
																				lowerCamelCase_								=[]
																				lowerCamelCase_								=0
																				while i < len(_SCREAMING_SNAKE_CASE							):
																											try:
																																		lowerCamelCase_								=word.index(_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							)
																											except ValueError:
																																		new_word.extend(word[i:]							)
																																		break
																											else:
																																		new_word.extend(word[i:j]							)
																																		lowerCamelCase_								=j

																											if word[i] == first and i < len(_SCREAMING_SNAKE_CASE							) - 1 and word[i + 1] == second:
																																		new_word.append(first + second							)
																																		i += 2
																											else:
																																		new_word.append(word[i]							)
																																		i += 1
																				lowerCamelCase_								=tuple(_SCREAMING_SNAKE_CASE							)
																				lowerCamelCase_								=new_word
																				if len(_SCREAMING_SNAKE_CASE							) == 1:
																											break
																				else:
																											lowerCamelCase_								=get_pairs(_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=""" """.join(_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=word
													return word







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE=None							)->							Any:
													if self.add_bos_token:
																				lowerCamelCase_								=[self.bos_token_id]
													else:
																				lowerCamelCase_								=[]

													lowerCamelCase_								=bos_token_ids + token_ids_a

													if token_ids_a is None:
																				return output

													return output + bos_token_ids + token_ids_a







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE = None     ,						_SCREAMING_SNAKE_CASE = False							)->							List[int]:
													if already_has_special_tokens:
																				return super().get_special_tokens_mask(
																				    token_ids_a=_SCREAMING_SNAKE_CASE     ,						token_ids_a=_SCREAMING_SNAKE_CASE     ,						already_has_special_tokens=_SCREAMING_SNAKE_CASE							)

													if not self.add_bos_token:
																				return super().get_special_tokens_mask(
																				    token_ids_a=_SCREAMING_SNAKE_CASE     ,						token_ids_a=_SCREAMING_SNAKE_CASE     ,						already_has_special_tokens=_SCREAMING_SNAKE_CASE							)

													if token_ids_a is None:
																				return [1] + ([0] * len(_SCREAMING_SNAKE_CASE							))
													return [1] + ([0] * len(_SCREAMING_SNAKE_CASE							)) + [1] + ([0] * len(_SCREAMING_SNAKE_CASE							))







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE							)->							Any:
													lowerCamelCase_								=[]
													for token in re.findall(self.pat     ,						_SCREAMING_SNAKE_CASE							):
																				lowerCamelCase_								="""""".join(
																				    self.byte_encoder[b] for b in token.encode("""utf-8"""							)							)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
																				bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_SCREAMING_SNAKE_CASE							).split(""" """							)							)
													return bpe_tokens







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE							)->							List[str]:
													return self.encoder.get(_SCREAMING_SNAKE_CASE     ,						self.encoder.get(self.unk_token							)							)







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE							)->							int:
													return self.decoder.get(_SCREAMING_SNAKE_CASE							)







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE							)->							int:
													lowerCamelCase_								="""""".join(_SCREAMING_SNAKE_CASE							)
													lowerCamelCase_								=bytearray([self.byte_decoder[c] for c in text]							).decode("""utf-8"""     ,						errors=self.errors							)
													return text







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE = None							)->							Tuple[str]:
													if not os.path.isdir(_SCREAMING_SNAKE_CASE							):
																				logger.error(f'Vocabulary path ({save_directory}) should be a directory'							)
																				return
													lowerCamelCase_								=os.path.join(
													    _SCREAMING_SNAKE_CASE     ,						(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]							)
													lowerCamelCase_								=os.path.join(
													    _SCREAMING_SNAKE_CASE     ,						(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]							)

													with open(_SCREAMING_SNAKE_CASE     ,						"""w"""     ,						encoding="""utf-8"""							) as f:
																				f.write(json.dumps(self.encoder     ,						indent=2     ,						sort_keys=_SCREAMING_SNAKE_CASE     ,						ensure_ascii=_SCREAMING_SNAKE_CASE							) + """\n"""							)

													lowerCamelCase_								=0
													with open(_SCREAMING_SNAKE_CASE     ,						"""w"""     ,						encoding="""utf-8"""							) as writer:
																				writer.write("""#version: 0.2\n"""							)
																				for bpe_tokens, token_index in sorted(self.bpe_ranks.items()     ,						key=lambda _SCREAMING_SNAKE_CASE							: kv[1]							):
																											if index != token_index:
																																		logger.warning(
																																		    f'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
																																		    """ Please check that the tokenizer is not corrupted!"""							)
																																		lowerCamelCase_								=token_index
																											writer.write(""" """.join(_SCREAMING_SNAKE_CASE							) + """\n"""							)
																											index += 1

													return vocab_file, merge_file







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE=False     ,						**_SCREAMING_SNAKE_CASE							)->							Optional[Any]:
													lowerCamelCase_								=kwargs.pop("""add_prefix_space"""     ,						self.add_prefix_space							)
													if is_split_into_words or add_prefix_space:
																				lowerCamelCase_								=""" """ + text
													return (text, kwargs)







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE							)->							List[int]:
													lowerCamelCase_								=[]
													for is_user, text in conversation.iter_texts():
																				input_ids.extend(self.encode(_SCREAMING_SNAKE_CASE     ,						add_special_tokens=_SCREAMING_SNAKE_CASE							) + [self.eos_token_id]							)
													if len(_SCREAMING_SNAKE_CASE							) > self.model_max_length:
																				lowerCamelCase_								=input_ids[-self.model_max_length :]
													return input_ids
