






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

import numpy as np
import regex as re

from ...utils import is_tf_available, is_torch_available, logging


if TYPE_CHECKING:
				if is_torch_available():
								import torch
				if is_tf_available():
								import tensorflow as tf

from ...tokenization_utils import AddedToken, PreTrainedTokenizer


UpperCamelCase__  :					int  						=    logging.get_logger(__name__)

UpperCamelCase__  :					Tuple  						=    {
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
}

UpperCamelCase__  :					Any  						=    {
    "vocab_file": {
        "Salesforce/codegen-350M-mono": "https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/vocab.json",
    },
    "merges_file": {
        "Salesforce/codegen-350M-mono": "https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/merges.txt",
    },
}

UpperCamelCase__  :					Dict  						=    {
    "Salesforce/codegen-350M-mono": 2_048,
}





@lru_cache()
def      SCREAMING_SNAKE_CASE__  (      )      ->     List[str]:


	"""simple docstring"""



	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      SCREAMING_SNAKE_CASE__  (      snake_case_     )      ->     int:


	"""simple docstring"""



	a				=	set()
	a				=	word[0]
	for char in word[1:]:
		pairs.add((prev_char, char)     )
		a				=	char
	return pairs







class  lowerCamelCase_   (		UpperCamelCase__   ):
							SCREAMING_SNAKE_CASE_     =	VOCAB_FILES_NAMES
							SCREAMING_SNAKE_CASE_     =	PRETRAINED_VOCAB_FILES_MAP
							SCREAMING_SNAKE_CASE_     =	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							SCREAMING_SNAKE_CASE_     =	["""input_ids""", """attention_mask"""]
							def __init__(  self						:    Any							,__lowerCamelCase						:    Optional[Any]							,__lowerCamelCase						:    Optional[Any]							,__lowerCamelCase						:    int="replace"							,__lowerCamelCase						:    Any="<|endoftext|>"							,__lowerCamelCase						:    Tuple="<|endoftext|>"							,__lowerCamelCase						:    int="<|endoftext|>"							,__lowerCamelCase						:    Tuple=None							,__lowerCamelCase						:    str=False							,__lowerCamelCase						:    Dict=False							,**__lowerCamelCase						:    List[str]							,):





								'''simple docstring'''



								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 unk_token
								a				=	AddedToken(__lowerCamelCase							,lstrip=__lowerCamelCase							,rstrip=__lowerCamelCase    ) if isinstance(__lowerCamelCase							,__lowerCamelCase    ) else pad_token
								super().__init__(
								    errors=__lowerCamelCase							,unk_token=__lowerCamelCase							,bos_token=__lowerCamelCase							,eos_token=__lowerCamelCase							,pad_token=__lowerCamelCase							,add_prefix_space=__lowerCamelCase							,add_bos_token=__lowerCamelCase							,**__lowerCamelCase							,)
								a				=	add_bos_token

								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        SCREAMING_SNAKE_CASE_       (  self						:    str    ):





								'''simple docstring'''



								return len(self.encoder    )
							def        SCREAMING_SNAKE_CASE_       (  self						:    Tuple    ):





								'''simple docstring'''



								return dict(self.encoder							,**self.added_tokens_encoder    )
							def        SCREAMING_SNAKE_CASE_       (  self						:    Dict							,__lowerCamelCase						:    Optional[int]    ):





								'''simple docstring'''



								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        SCREAMING_SNAKE_CASE_       (  self						:    Union[str, Any]							,__lowerCamelCase						:    str							,__lowerCamelCase						:    Dict=None    ):





								'''simple docstring'''



								if self.add_bos_token:
									a				=	[self.bos_token_id]
								else:
									a				=	[]

								a				=	bos_token_ids + token_ids_a

								if token_ids_a is None:
									return output

								return output + bos_token_ids + token_ids_a
							def        SCREAMING_SNAKE_CASE_       (  self						:    Dict							,__lowerCamelCase						:    str    ):





								'''simple docstring'''



								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        SCREAMING_SNAKE_CASE_       (  self						:    int							,__lowerCamelCase						:    Any    ):





								'''simple docstring'''



								return self.encoder.get(__lowerCamelCase							,self.encoder.get(self.unk_token    )    )
							def        SCREAMING_SNAKE_CASE_       (  self						:    int							,__lowerCamelCase						:    List[Any]    ):





								'''simple docstring'''



								return self.decoder.get(__lowerCamelCase    )
							def        SCREAMING_SNAKE_CASE_       (  self						:    int							,__lowerCamelCase						:    List[str]    ):





								'''simple docstring'''



								a				=	''''''.join(__lowerCamelCase    )
								a				=	bytearray([self.byte_decoder[c] for c in text]    ).decode('''utf-8'''							,errors=self.errors    )
								return text
							def        SCREAMING_SNAKE_CASE_       (  self						:    Union[str, Any]							,__lowerCamelCase						:    Dict							,__lowerCamelCase						:    Tuple = None    ):





								'''simple docstring'''



								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        SCREAMING_SNAKE_CASE_       (  self						:    Tuple							,__lowerCamelCase						:    List[str]							,__lowerCamelCase						:    int=False							,**__lowerCamelCase						:    Union[str, Any]    ):





								'''simple docstring'''



								a				=	kwargs.pop('''add_prefix_space'''							,self.add_prefix_space    )
								if is_split_into_words or add_prefix_space:
									a				=	''' ''' + text
								return (text, kwargs)
							def        SCREAMING_SNAKE_CASE_       (  self						:    Tuple							,__lowerCamelCase						:    Optional[Any]							,__lowerCamelCase						:    Any = False							,__lowerCamelCase						:    List[Any] = None							,__lowerCamelCase						:    str = None							,**__lowerCamelCase						:    Any							,):





								'''simple docstring'''



								a				=	super()._decode(
								    token_ids=__lowerCamelCase							,skip_special_tokens=__lowerCamelCase							,clean_up_tokenization_spaces=__lowerCamelCase							,**__lowerCamelCase							,)

								if truncate_before_pattern is not None and len(__lowerCamelCase    ) > 0:
									a				=	self.truncate(__lowerCamelCase							,__lowerCamelCase    )

								return decoded_text




							def        SCREAMING_SNAKE_CASE_       (  self						:    List[str]							,__lowerCamelCase						:    Optional[int]							,__lowerCamelCase						:    Tuple    ):





								'''simple docstring'''



								def find_re(__lowerCamelCase						:    Tuple							,__lowerCamelCase						:    Dict							,__lowerCamelCase						:    Optional[int]    ):
									a				=	pattern.search(__lowerCamelCase							,__lowerCamelCase    )
									return m.start() if m else -1

								a				=	[re.compile(__lowerCamelCase							,re.MULTILINE    ) for pattern in truncate_before_pattern]

								a				=	list(re.finditer('''^print'''							,__lowerCamelCase							,re.MULTILINE    )    )

								if len(__lowerCamelCase    ) > 1:
									a				=	completion[: prints[1].start()]

								a				=	list(re.finditer('''^def'''							,__lowerCamelCase							,re.MULTILINE    )    )

								if len(__lowerCamelCase    ) > 1:
									a				=	completion[: defs[1].start()]

								a				=	0

								a				=	[
								    pos for pos in [find_re(__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase    ) for terminal in terminals] if pos != -1
								]

								if len(__lowerCamelCase    ) > 0:
									return completion[: min(__lowerCamelCase    )]
								else:
									return completion











import doctest

import projectq
from projectq.ops import H, Measure

def 					SCREAMING_SNAKE_CASE							(   __UpperCamelCase)			->     int:
     a      =      quantum_engine.allocate_qubit()
     H | qubit
     Measure | qubit
     return int(__UpperCamelCase)


if __name__ == "__main__":
   doctest.testmod()

   # initialises a new quantum backend
   lowercase__      :			Optional[int]           =					projectq.MainEngine()

   # Generate a list of 10 random numbers
   lowercase__      :			List[str]           =					[get_random_number(quantum_engine) for _ in range(10)]

   # Flushes the quantum engine from memory
   quantum_engine.flush()

   print("Random numbers", random_numbers_list)

