


'''simple docstring'''
def 			a_							(  UpperCamelCase_	,     UpperCamelCase_	,     UpperCamelCase_   ):
							A_ 						=		[1 / first_term]
							A_ 						=		1 / first_term
							for _ in range(number_of_terms - 1   ):
														first_term += common_difference
														arithmetic_progression.append(UpperCamelCase_   )
							A_ 						=		[1 / step for step in arithmetic_progression]
							return sum(UpperCamelCase_   )


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							print(sum_of_harmonic_progression(1 / 2, 2, 2))









'''simple docstring'''
import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

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


__SCREAMING_SNAKE_CASE				:							Optional[int]		       =		logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE				:							List[str]		       =		{
    '''vocab_file''': '''vocab.json''',
    '''merges_file''': '''merges.txt''',
}

__SCREAMING_SNAKE_CASE				:							int		       =		{
    '''vocab_file''': {
        '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/vocab.json''',
        '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/vocab.json''',
        '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json''',
        '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/vocab.json''',
        '''roberta-base-openai-detector''': '''https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json''',
        '''roberta-large-openai-detector''': (
            '''https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json'''
        ),
    },
    '''merges_file''': {
        '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/merges.txt''',
        '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/merges.txt''',
        '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt''',
        '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/merges.txt''',
        '''roberta-base-openai-detector''': '''https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt''',
        '''roberta-large-openai-detector''': (
            '''https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt'''
        ),
    },
}

__SCREAMING_SNAKE_CASE				:							int		       =		{
    '''roberta-base''': 512,
    '''roberta-large''': 512,
    '''roberta-large-mnli''': 512,
    '''distilroberta-base''': 512,
    '''roberta-base-openai-detector''': 512,
    '''roberta-large-openai-detector''': 512,
}







@lru_cache()
def 			a_							(  ):
							A_ 						=		(
							    list(range(ord("!"   )	,     ord("~"   ) + 1   )   ) + list(range(ord("¡"   )	,     ord("¬"   ) + 1   )   ) + list(range(ord("®"   )	,     ord("ÿ"   ) + 1   )   )
							)
							A_ 						=		bs[:]
							A_ 						=		0
							for b in range(2**8   ):
														if b not in bs:
																					bs.append(UpperCamelCase_   )
																					cs.append(2**8 + n   )
																					n += 1
							A_ 						=		[chr(UpperCamelCase_   ) for n in cs]
							return dict(zip(UpperCamelCase_	,     UpperCamelCase_   )   )







def 			a_							(  UpperCamelCase_   ):
							A_ 						=		set()
							A_ 						=		word[0]
							for char in word[1:]:
														pairs.add((prev_char, char)   )
														A_ 						=		char
							return pairs







class 				__lowerCAmelCase      (      lowercase	):

						"""simple docstring"""






						_UpperCAmelCase		:					List[str]      	=VOCAB_FILES_NAMES
						_UpperCAmelCase		:					Optional[Any]      	=PRETRAINED_VOCAB_FILES_MAP
						_UpperCAmelCase		:					List[Any]      	=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						_UpperCAmelCase		:					Optional[Any]      	=["input_ids", "attention_mask"]






						def __init__(     self       :			int   ,     lowerCAmelCase       :			int   ,     lowerCAmelCase       :			Optional[int]   ,     lowerCAmelCase       :			Any="replace"   ,     lowerCAmelCase       :			Optional[Any]="<s>"   ,     lowerCAmelCase       :			int="</s>"   ,     lowerCAmelCase       :			Tuple="</s>"   ,     lowerCAmelCase       :			Dict="<s>"   ,     lowerCAmelCase       :			Any="<unk>"   ,     lowerCAmelCase       :			str="<pad>"   ,     lowerCAmelCase       :			Tuple="<mask>"   ,     lowerCAmelCase       :			Tuple=False   ,     **lowerCAmelCase       :			str   ,     ):
													A_ 						=		AddedToken(lowerCAmelCase   ,     lstrip=lowerCAmelCase   ,     rstrip=lowerCAmelCase  ) if isinstance(lowerCAmelCase   ,     lowerCAmelCase  ) else bos_token
													A_ 						=		AddedToken(lowerCAmelCase   ,     lstrip=lowerCAmelCase   ,     rstrip=lowerCAmelCase  ) if isinstance(lowerCAmelCase   ,     lowerCAmelCase  ) else eos_token
													A_ 						=		AddedToken(lowerCAmelCase   ,     lstrip=lowerCAmelCase   ,     rstrip=lowerCAmelCase  ) if isinstance(lowerCAmelCase   ,     lowerCAmelCase  ) else sep_token
													A_ 						=		AddedToken(lowerCAmelCase   ,     lstrip=lowerCAmelCase   ,     rstrip=lowerCAmelCase  ) if isinstance(lowerCAmelCase   ,     lowerCAmelCase  ) else cls_token
													A_ 						=		AddedToken(lowerCAmelCase   ,     lstrip=lowerCAmelCase   ,     rstrip=lowerCAmelCase  ) if isinstance(lowerCAmelCase   ,     lowerCAmelCase  ) else unk_token
													A_ 						=		AddedToken(lowerCAmelCase   ,     lstrip=lowerCAmelCase   ,     rstrip=lowerCAmelCase  ) if isinstance(lowerCAmelCase   ,     lowerCAmelCase  ) else pad_token

													# Mask token behave like a normal word, i.e. include the space before it
													A_ 						=		AddedToken(lowerCAmelCase   ,     lstrip=lowerCAmelCase   ,     rstrip=lowerCAmelCase  ) if isinstance(lowerCAmelCase   ,     lowerCAmelCase  ) else mask_token

													super().__init__(
													    errors=lowerCAmelCase   ,     bos_token=lowerCAmelCase   ,     eos_token=lowerCAmelCase   ,     unk_token=lowerCAmelCase   ,     sep_token=lowerCAmelCase   ,     cls_token=lowerCAmelCase   ,     pad_token=lowerCAmelCase   ,     mask_token=lowerCAmelCase   ,     add_prefix_space=lowerCAmelCase   ,     **lowerCAmelCase   ,     )

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

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






						@property
						def 							_UpperCAmelCase					(     self       :			Optional[int]  ):
													return len(self.encoder  )






						def 							_UpperCAmelCase					(     self       :			List[Any]  ):
													return dict(self.encoder   ,     **self.added_tokens_encoder  )






						def 							_UpperCAmelCase					(     self       :			Optional[int]   ,     lowerCAmelCase       :			List[Any]  ):
													if token in self.cache:
																				return self.cache[token]
													A_ 						=		tuple(lowerCAmelCase  )
													A_ 						=		get_pairs(lowerCAmelCase  )

													if not pairs:
																				return token

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

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






						def 							_UpperCAmelCase					(     self       :			Optional[int]   ,     lowerCAmelCase       :			int  ):
													A_ 						=		[]
													for token in re.findall(self.pat   ,     lowerCAmelCase  ):
																				A_ 						=		"".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(lowerCAmelCase  ).split(" "  )  )
													return bpe_tokens






						def 							_UpperCAmelCase					(     self       :			str   ,     lowerCAmelCase       :			List[str]  ):
													return self.encoder.get(lowerCAmelCase   ,     self.encoder.get(self.unk_token  )  )






						def 							_UpperCAmelCase					(     self       :			List[str]   ,     lowerCAmelCase       :			Union[str, Any]  ):
													return self.decoder.get(lowerCAmelCase  )






						def 							_UpperCAmelCase					(     self       :			List[str]   ,     lowerCAmelCase       :			Tuple  ):
													A_ 						=		"".join(lowerCAmelCase  )
													A_ 						=		bytearray([self.byte_decoder[c] for c in text]  ).decode("utf-8"   ,     errors=self.errors  )
													return text






						def 							_UpperCAmelCase					(     self       :			Dict   ,     lowerCAmelCase       :			str   ,     lowerCAmelCase       :			Optional[str] = None  ):
													if not os.path.isdir(lowerCAmelCase  ):
																				logger.error(F"Vocabulary path ({save_directory}) should be a directory"  )
																				return
													A_ 						=		os.path.join(
													    lowerCAmelCase   ,     (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]  )
													A_ 						=		os.path.join(
													    lowerCAmelCase   ,     (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]  )

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

													A_ 						=		0
													with open(lowerCAmelCase   ,     "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 lowerCAmelCase  : 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!"  )
																																		A_ 						=		token_index
																											writer.write(" ".join(lowerCAmelCase  ) + "\n"  )
																											index += 1

													return vocab_file, merge_file






						def 							_UpperCAmelCase					(     self       :			Union[str, Any]   ,     lowerCAmelCase       :			List[int]   ,     lowerCAmelCase       :			Optional[List[int]] = None  ):
													if token_ids_a is None:
																				return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
													A_ 						=		[self.cls_token_id]
													A_ 						=		[self.sep_token_id]
													return cls + token_ids_a + sep + sep + token_ids_a + sep






						def 							_UpperCAmelCase					(     self       :			List[str]   ,     lowerCAmelCase       :			List[int]   ,     lowerCAmelCase       :			Optional[List[int]] = None   ,     lowerCAmelCase       :			bool = False  ):
													if already_has_special_tokens:
																				return super().get_special_tokens_mask(
																				    token_ids_a=lowerCAmelCase   ,     token_ids_a=lowerCAmelCase   ,     already_has_special_tokens=lowerCAmelCase  )

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






						def 							_UpperCAmelCase					(     self       :			Optional[Any]   ,     lowerCAmelCase       :			List[int]   ,     lowerCAmelCase       :			Optional[List[int]] = None  ):
													A_ 						=		[self.sep_token_id]
													A_ 						=		[self.cls_token_id]

													if token_ids_a is None:
																				return len(cls + token_ids_a + sep  ) * [0]
													return len(cls + token_ids_a + sep + sep + token_ids_a + sep  ) * [0]






						def 							_UpperCAmelCase					(     self       :			Tuple   ,     lowerCAmelCase       :			List[Any]   ,     lowerCAmelCase       :			str=False   ,     **lowerCAmelCase       :			Optional[Any]  ):
													A_ 						=		kwargs.pop("add_prefix_space"   ,     self.add_prefix_space  )
													if (is_split_into_words or add_prefix_space) and (len(lowerCAmelCase  ) > 0 and not text[0].isspace()):
																				A_ 						=		" " + text
													return (text, kwargs)





