




from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional

from packaging import version


if TYPE_CHECKING:
						from ... import PreTrainedTokenizer, TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import is_torch_available, logging


UpperCamelCase__ :   str						=							logging.get_logger(__name__)

UpperCamelCase__ :   Any						=							{
    '''bigscience/bloom''': '''https://huggingface.co/bigscience/bloom/resolve/main/config.json''',
    '''bigscience/bloom-560m''': '''https://huggingface.co/bigscience/bloom-560m/blob/main/config.json''',
    '''bigscience/bloom-1b1''': '''https://huggingface.co/bigscience/bloom-1b1/blob/main/config.json''',
    '''bigscience/bloom-1b7''': '''https://huggingface.co/bigscience/bloom-1b7/blob/main/config.json''',
    '''bigscience/bloom-3b''': '''https://huggingface.co/bigscience/bloom-3b/blob/main/config.json''',
    '''bigscience/bloom-7b1''': '''https://huggingface.co/bigscience/bloom-7b1/blob/main/config.json''',
}







class 				lowerCAmelCase_       (					lowerCamelCase_							):
				__a     :       Dict						=     "bloom"
				__a     :       Any						=     ["past_key_values"]
				__a     :       Union[str, Any]						=     {
				    "num_hidden_layers": "n_layer",
				    "num_attention_heads": "n_head",
				}






				def __init__(			self      ,snake_case__=250880      ,snake_case__=64      ,snake_case__=2      ,snake_case__=8      ,snake_case__=1E-5      ,snake_case__=0.02      ,snake_case__=True      ,snake_case__=1      ,snake_case__=2      ,snake_case__=False      ,snake_case__=0.0      ,snake_case__=0.0      ,snake_case__=1      ,snake_case__=False      ,**snake_case__      ,):
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      vocab_size
							# Backward compatibility with n_embed kwarg
							SCREAMING_SNAKE_CASE_   : Tuple					  =      kwargs.pop('n_embed'      ,snake_case__ )
							SCREAMING_SNAKE_CASE_   : int					  =      hidden_size if n_embed is None else n_embed
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      n_layer
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      n_head
							SCREAMING_SNAKE_CASE_   : List[str]					  =      layer_norm_epsilon
							SCREAMING_SNAKE_CASE_   : Tuple					  =      initializer_range
							SCREAMING_SNAKE_CASE_   : List[str]					  =      use_cache
							SCREAMING_SNAKE_CASE_   : int					  =      pretraining_tp
							SCREAMING_SNAKE_CASE_   : int					  =      apply_residual_connection_post_layernorm
							SCREAMING_SNAKE_CASE_   : Tuple					  =      hidden_dropout
							SCREAMING_SNAKE_CASE_   : List[str]					  =      attention_dropout

							SCREAMING_SNAKE_CASE_   : str					  =      bos_token_id
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      eos_token_id
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      slow_but_exact

							super().__init__(bos_token_id=snake_case__      ,eos_token_id=snake_case__      ,**snake_case__ )







class 				lowerCAmelCase_       (					lowerCamelCase_							):
				__a     :       List[Any]						=     version.parse("1.12"							)






				def __init__(			self      ,snake_case__      ,snake_case__ = "default"      ,snake_case__ = None      ,snake_case__ = False      ,):
							super().__init__(snake_case__      ,task=snake_case__      ,patching_specs=snake_case__      ,use_past=snake_case__ )
							if not getattr(self._config      ,'pad_token_id'      ,snake_case__ ):
										# TODO: how to do that better?
										SCREAMING_SNAKE_CASE_   : str					  =      0






				@property
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Dict					  =      OrderedDict({'input_ids': {0: 'batch', 1: 'sequence'}} )
							if self.use_past:
										# BLOOM stores values on dynamic axis 2. For more details see: https://github.com/huggingface/transformers/pull/18344
										self.fill_with_past_key_values_(snake_case__      ,direction='inputs'      ,inverted_values_shape=snake_case__ )
										SCREAMING_SNAKE_CASE_   : Optional[int]					  =      {0: 'batch', 1: 'past_sequence + sequence'}
							else:
										SCREAMING_SNAKE_CASE_   : int					  =      {0: 'batch', 1: 'sequence'}

							return common_inputs






				@property
				def 		snake_case	(			self ):
							return self._config.n_layer






				@property
				def 		snake_case	(			self ):
							return self._config.n_head






				@property
				def 		snake_case	(			self ):
							return 1E-3






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ = -1      ,snake_case__ = -1      ,snake_case__ = False      ,snake_case__ = None      ,):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      super(snake_case__      ,self ).generate_dummy_inputs(
							    snake_case__      ,batch_size=snake_case__      ,seq_length=snake_case__      ,is_pair=snake_case__      ,framework=snake_case__ )

							# We need to order the input in the way they appears in the forward()
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      OrderedDict({'input_ids': common_inputs['input_ids']} )

							# Need to add the past_keys
							if self.use_past:
										if not is_torch_available():
													raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.' )
										else:
													import torch

													SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : List[Any]					  =      common_inputs['input_ids'].shape
													# Not using the same length for past_key_values
													SCREAMING_SNAKE_CASE_   : List[Any]					  =      seqlen + 2
													SCREAMING_SNAKE_CASE_   : Any					  =      self._config.hidden_size // self.num_attention_heads
													SCREAMING_SNAKE_CASE_   : List[str]					  =      (
													    batch * self.num_attention_heads,
													    head_dim,
													    past_key_values_length,
													)
													SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      (
													    batch * self.num_attention_heads,
													    past_key_values_length,
													    head_dim,
													)
													SCREAMING_SNAKE_CASE_   : Dict					  =      [
													    (torch.zeros(snake_case__ ), torch.zeros(snake_case__ )) for _ in range(self.num_layers )
													]

							SCREAMING_SNAKE_CASE_   : Tuple					  =      common_inputs['attention_mask']
							if self.use_past:
										SCREAMING_SNAKE_CASE_   : Any					  =      ordered_inputs['attention_mask'].dtype
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      torch.cat(
										    [ordered_inputs['attention_mask'], torch.ones(snake_case__      ,snake_case__      ,dtype=snake_case__ )]      ,dim=1 )

							return ordered_inputs






				@property
				def 		snake_case	(			self ):
							return 13







import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roberta import RobertaTokenizer


snake_case							:       List[Any]										=	logging.get_logger(__name__)

snake_case							:       Optional[int]										=	{'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}

snake_case							:       Union[str, Any]										=	{
    '''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'''
        ),
    },
    '''tokenizer_file''': {
        '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/tokenizer.json''',
        '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/tokenizer.json''',
        '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/tokenizer.json''',
        '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/tokenizer.json''',
        '''roberta-base-openai-detector''': (
            '''https://huggingface.co/roberta-base-openai-detector/resolve/main/tokenizer.json'''
        ),
        '''roberta-large-openai-detector''': (
            '''https://huggingface.co/roberta-large-openai-detector/resolve/main/tokenizer.json'''
        ),
    },
}

snake_case							:       Optional[int]										=	{
    '''roberta-base''': 5_12,
    '''roberta-large''': 5_12,
    '''roberta-large-mnli''': 5_12,
    '''distilroberta-base''': 5_12,
    '''roberta-base-openai-detector''': 5_12,
    '''roberta-large-openai-detector''': 5_12,
}







class 						_snake_case    ( _snake_case				):
 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']
 SCREAMING_SNAKE_CASE__ =			RobertaTokenizer




 def __init__(						self   ,    _lowerCamelCase=None   ,    _lowerCamelCase=None   ,    _lowerCamelCase=None   ,    _lowerCamelCase="replace"   ,    _lowerCamelCase="<s>"   ,    _lowerCamelCase="</s>"   ,    _lowerCamelCase="</s>"   ,    _lowerCamelCase="<s>"   ,    _lowerCamelCase="<unk>"   ,    _lowerCamelCase="<pad>"   ,    _lowerCamelCase="<mask>"   ,    _lowerCamelCase=False   ,    _lowerCamelCase=True   ,    **_lowerCamelCase   ,    ):
       super().__init__(
           _lowerCamelCase   ,    _lowerCamelCase   ,    tokenizer_file=_lowerCamelCase   ,    errors=_lowerCamelCase   ,    bos_token=_lowerCamelCase   ,    eos_token=_lowerCamelCase   ,    sep_token=_lowerCamelCase   ,    cls_token=_lowerCamelCase   ,    unk_token=_lowerCamelCase   ,    pad_token=_lowerCamelCase   ,    mask_token=_lowerCamelCase   ,    add_prefix_space=_lowerCamelCase   ,    trim_offsets=_lowerCamelCase   ,    **_lowerCamelCase   ,    )

       a		:List[Any]									=			json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()       )
       if pre_tok_state.get('''add_prefix_space'''   ,    _lowerCamelCase       ) != add_prefix_space:
             a		:Optional[int]									=			getattr(_lowerCamelCase   ,    pre_tok_state.pop('''type'''       )       )
             a		:Union[str, Any]									=			add_prefix_space
             a		:Dict									=			pre_tok_class(**_lowerCamelCase       )

       a		:Union[str, Any]									=			add_prefix_space

       a		:List[Any]									=			'''post_processor'''
       a		:List[str]									=			getattr(self.backend_tokenizer   ,    _lowerCamelCase   ,    _lowerCamelCase       )
       if tokenizer_component_instance:
             a		:Optional[Any]									=			json.loads(tokenizer_component_instance.__getstate__()       )

             # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
             if "sep" in state:
                   a		:Optional[int]									=			tuple(state['''sep''']       )
             if "cls" in state:
                   a		:Union[str, Any]									=			tuple(state['''cls''']       )

             a		:Optional[int]									=			False

             if state.get('''add_prefix_space'''   ,    _lowerCamelCase       ) != add_prefix_space:
                   a		:int									=			add_prefix_space
                   a		:Union[str, Any]									=			True

             if state.get('''trim_offsets'''   ,    _lowerCamelCase       ) != trim_offsets:
                   a		:int									=			trim_offsets
                   a		:List[str]									=			True

             if changes_to_apply:
                   a		:Union[str, Any]									=			getattr(_lowerCamelCase   ,    state.pop('''type'''       )       )
                   a		:str									=			component_class(**_lowerCamelCase       )
                   setattr(self.backend_tokenizer   ,    _lowerCamelCase   ,    _lowerCamelCase       )




 @property
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       if self._mask_token is None:
             if self.verbose:
                   logger.error('''Using mask_token, but it is not set yet.'''       )
             return None
       return str(self._mask_token       )




 @mask_token.setter
 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase       ):
       a		:Union[str, Any]									=			AddedToken(_lowerCamelCase   ,    lstrip=_lowerCamelCase   ,    rstrip=_lowerCamelCase       ) if isinstance(_lowerCamelCase   ,    _lowerCamelCase       ) else value
       a		:int									=			value




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    *_lowerCamelCase   ,    **_lowerCamelCase       ):
       a		:Union[str, Any]									=			kwargs.get('''is_split_into_words'''   ,    _lowerCamelCase       )
       assert self.add_prefix_space or not is_split_into_words, (
           F'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
           "to use it with pretokenized inputs."
       )

       return super()._batch_encode_plus(*_lowerCamelCase   ,    **_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    *_lowerCamelCase   ,    **_lowerCamelCase       ):
       a		:Any									=			kwargs.get('''is_split_into_words'''   ,    _lowerCamelCase       )

       assert self.add_prefix_space or not is_split_into_words, (
           F'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
           "to use it with pretokenized inputs."
       )

       return super()._encode_plus(*_lowerCamelCase   ,    **_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase = None       ):
       a		:Any									=			self._tokenizer.model.save(_lowerCamelCase   ,    name=_lowerCamelCase       )
       return tuple(_lowerCamelCase       )




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase=None       ):
       a		:Union[str, Any]									=			[self.bos_token_id] + token_ids_a + [self.eos_token_id]
       if token_ids_a is None:
             return output

       return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase = None       ):
       a		:Dict									=			[self.sep_token_id]
       a		:int									=			[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]





