


from typing import Dict, List, Optional

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


UpperCAmelCase_      : str  					=       logging.get_logger(__name__)


UpperCAmelCase_      : List[Any]  					=       {
    'nielsr/canine-s': 2048,
}

# Unicode defines 1,114,112 total “codepoints”
UpperCAmelCase_      : Union[str, Any]  					=       111_4112

# Below: Constants defining canonical codepoints for special, pseudo-characters.
# Copied from https://github.com/google-research/language/blob/master/language/canine/special_codepoints.py
UpperCAmelCase_      : List[str]  					=       0

UpperCAmelCase_      : str  					=       0Xe_000
UpperCAmelCase_      : Optional[Any]  					=       0Xe_001
UpperCAmelCase_      : Union[str, Any]  					=       0Xe_002
UpperCAmelCase_      : Tuple  					=       0Xe_003
UpperCAmelCase_      : List[Any]  					=       0Xe_004

# Maps special codepoints to human-readable names.
UpperCAmelCase_      : Dict[int, str]  					=       {
    # Special symbols are represented using codepoints values that are valid,
    # but designated as "Private Use", meaning that they will never be assigned
    # characters by the Unicode Consortium, and are thus safe for use here.
    #
    # NOTE: Do *NOT* add any sort of [UNK_CHAR] here. They are explicitly
    # excluded and should fail with a hard error.
    CLS: "[CLS]",
    SEP: "[SEP]",
    BOS: "[BOS]",
    MASK: "[MASK]",
    PAD: "[PAD]",
    RESERVED: "[RESERVED]",
}

# Maps special codepoint human-readable names to their codepoint values.
UpperCAmelCase_      : Dict[str, int]  					=       {name: codepoint for codepoint, name in SPECIAL_CODEPOINTS.items()}
class  SCREAMING_SNAKE_CASE__  (				lowercase__			):
      snake_case__				:     int        =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      def __init__(       self				:       Optional[int]     ,							SCREAMING_SNAKE_CASE__				:       Tuple=chr(SCREAMING_SNAKE_CASE__     )     ,							SCREAMING_SNAKE_CASE__				:       Any=chr(SCREAMING_SNAKE_CASE__     )     ,							SCREAMING_SNAKE_CASE__				:       str=chr(SCREAMING_SNAKE_CASE__     )     ,							SCREAMING_SNAKE_CASE__				:       int=chr(SCREAMING_SNAKE_CASE__     )     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]=chr(SCREAMING_SNAKE_CASE__     )     ,							SCREAMING_SNAKE_CASE__				:       int=chr(SCREAMING_SNAKE_CASE__     )     ,							SCREAMING_SNAKE_CASE__				:       List[str]=False     ,							SCREAMING_SNAKE_CASE__				:       List[str]=2_0_4_8     ,							**SCREAMING_SNAKE_CASE__				:       List[Any]     ,							)		->			List[Any]:
             a_					:		List[str]							=  AddedToken(SCREAMING_SNAKE_CASE__     ,							lstrip=SCREAMING_SNAKE_CASE__     ,							rstrip=SCREAMING_SNAKE_CASE__     ) if isinstance(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     ) else bos_token
             a_					:		Optional[Any]							=  AddedToken(SCREAMING_SNAKE_CASE__     ,							lstrip=SCREAMING_SNAKE_CASE__     ,							rstrip=SCREAMING_SNAKE_CASE__     ) if isinstance(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     ) else eos_token
             a_					:		Optional[int]							=  AddedToken(SCREAMING_SNAKE_CASE__     ,							lstrip=SCREAMING_SNAKE_CASE__     ,							rstrip=SCREAMING_SNAKE_CASE__     ) if isinstance(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     ) else sep_token
             a_					:		Union[str, Any]							=  AddedToken(SCREAMING_SNAKE_CASE__     ,							lstrip=SCREAMING_SNAKE_CASE__     ,							rstrip=SCREAMING_SNAKE_CASE__     ) if isinstance(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     ) else cls_token
             a_					:		Tuple							=  AddedToken(SCREAMING_SNAKE_CASE__     ,							lstrip=SCREAMING_SNAKE_CASE__     ,							rstrip=SCREAMING_SNAKE_CASE__     ) if isinstance(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     ) else pad_token

             # Mask token behave like a normal word, i.e. include the space before it
             a_					:		Optional[Any]							=  AddedToken(SCREAMING_SNAKE_CASE__     ,							lstrip=SCREAMING_SNAKE_CASE__     ,							rstrip=SCREAMING_SNAKE_CASE__     ) if isinstance(SCREAMING_SNAKE_CASE__     ,							SCREAMING_SNAKE_CASE__     ) else mask_token

             super().__init__(
                 bos_token=SCREAMING_SNAKE_CASE__     ,							eos_token=SCREAMING_SNAKE_CASE__     ,							sep_token=SCREAMING_SNAKE_CASE__     ,							cls_token=SCREAMING_SNAKE_CASE__     ,							pad_token=SCREAMING_SNAKE_CASE__     ,							mask_token=SCREAMING_SNAKE_CASE__     ,							add_prefix_space=SCREAMING_SNAKE_CASE__     ,							model_max_length=SCREAMING_SNAKE_CASE__     ,							**SCREAMING_SNAKE_CASE__     ,							)

             # Creates a mapping for looking up the IDs of special symbols.
             a_					:		Dict[str, int]							=  {}
             for codepoint, name in SPECIAL_CODEPOINTS.items():
                    a_					:		Optional[int]							=  codepoint

             # Creates a mapping for looking up the string forms of special symbol IDs.
             a_					:		Dict[int, str]							=  {
                 codepoint: name for name, codepoint in self._special_codepoints.items()
             }

             a_					:		Dict							=  UNICODE_VOCAB_SIZE
             a_					:		Any							=  len(self._special_codepoints     )
      @property
      def        SCREAMING_SNAKE_CASE							(       self				:       str     )		->			int:
             return self._unicode_vocab_size
      def        SCREAMING_SNAKE_CASE							(       self				:       Union[str, Any]     ,							SCREAMING_SNAKE_CASE__				:       str     )		->			List[str]:
             return list(SCREAMING_SNAKE_CASE__     )
      def        SCREAMING_SNAKE_CASE							(       self				:       int     ,							SCREAMING_SNAKE_CASE__				:       str     )		->			int:
             try:
                    return ord(SCREAMING_SNAKE_CASE__     )
             except TypeError:
                    raise ValueError(F"""invalid token: '{token}'"""     )
      def        SCREAMING_SNAKE_CASE							(       self				:       Any     ,							SCREAMING_SNAKE_CASE__				:       int     )		->			str:
             try:
                    if index in SPECIAL_CODEPOINTS:
                           return SPECIAL_CODEPOINTS[index]
                    return chr(SCREAMING_SNAKE_CASE__     )
             except TypeError:
                    raise ValueError(F"""invalid id: {index}"""     )
      def        SCREAMING_SNAKE_CASE							(       self				:       Union[str, Any]     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]     )		->			Union[str, Any]:
             return "".join(SCREAMING_SNAKE_CASE__     )
      def        SCREAMING_SNAKE_CASE							(       self				:       Dict     ,							SCREAMING_SNAKE_CASE__				:       List[int]     ,							SCREAMING_SNAKE_CASE__				:       Optional[List[int]] = None     )		->			List[int]:
             a_					:		int							=  [self.sep_token_id]
             a_					:		Optional[int]							=  [self.cls_token_id]

             a_					:		Optional[int]							=  cls + token_ids_a + sep
             if token_ids_a is not None:
                    result += token_ids_a + sep
             return result
      def        SCREAMING_SNAKE_CASE							(       self				:       List[str]     ,							SCREAMING_SNAKE_CASE__				:       List[int]     ,							SCREAMING_SNAKE_CASE__				:       Optional[List[int]] = None     ,							SCREAMING_SNAKE_CASE__				:       bool = 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__     )

             a_					:		Dict							=  [1] + ([0] * len(SCREAMING_SNAKE_CASE__     )) + [1]
             if token_ids_a is not None:
                    result += ([0] * len(SCREAMING_SNAKE_CASE__     )) + [1]
             return result
      def        SCREAMING_SNAKE_CASE							(       self				:       List[Any]     ,							SCREAMING_SNAKE_CASE__				:       List[int]     ,							SCREAMING_SNAKE_CASE__				:       Optional[List[int]] = None     )		->			List[int]:
             a_					:		int							=  [self.sep_token_id]
             a_					:		int							=  [self.cls_token_id]

             a_					:		Optional[Any]							=  len(cls + token_ids_a + sep     ) * [0]
             if token_ids_a is not None:
                    result += len(token_ids_a + sep     ) * [1]
             return result

      def        SCREAMING_SNAKE_CASE							(       self				:       int     ,							SCREAMING_SNAKE_CASE__				:       str     ,							SCREAMING_SNAKE_CASE__				:       Optional[str] = None     )		->			Union[str, Any]:
             return ()






from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_      : Dict  					=       logging.get_logger(__name__)

UpperCAmelCase_      : Union[str, Any]  					=       {
    'google/switch-base-8': 'https://huggingface.co/google/switch-base-8/blob/main/config.json',
}
class  SCREAMING_SNAKE_CASE__  (				lowercase__			):
      snake_case__				:     List[str]        =						'''switch_transformers'''
      snake_case__				:     Optional[int]        =						['''past_key_values''']
      snake_case__				:     Optional[Any]        =						{'''hidden_size''': '''d_model''', '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers'''}
      def __init__(       self				:       Dict     ,							SCREAMING_SNAKE_CASE__				:       Optional[int]=3_2_1_2_8     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]=7_6_8     ,							SCREAMING_SNAKE_CASE__				:       Optional[Any]=6_4     ,							SCREAMING_SNAKE_CASE__				:       List[str]=2_0_4_8     ,							SCREAMING_SNAKE_CASE__				:       Dict=6_4     ,							SCREAMING_SNAKE_CASE__				:       List[Any]=1_2     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]=3     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]=1_2     ,							SCREAMING_SNAKE_CASE__				:       str=3     ,							SCREAMING_SNAKE_CASE__				:       Tuple=1_2     ,							SCREAMING_SNAKE_CASE__				:       Tuple=8     ,							SCREAMING_SNAKE_CASE__				:       Dict=False     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]=0.01     ,							SCREAMING_SNAKE_CASE__				:       str="float32"     ,							SCREAMING_SNAKE_CASE__				:       str=False     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]=3_2     ,							SCREAMING_SNAKE_CASE__				:       Dict=1_2_8     ,							SCREAMING_SNAKE_CASE__				:       Dict=0.1     ,							SCREAMING_SNAKE_CASE__				:       Dict=1E-6     ,							SCREAMING_SNAKE_CASE__				:       Dict=0.001     ,							SCREAMING_SNAKE_CASE__				:       Any=0.001     ,							SCREAMING_SNAKE_CASE__				:       Optional[int]=1.0     ,							SCREAMING_SNAKE_CASE__				:       Any="relu"     ,							SCREAMING_SNAKE_CASE__				:       List[Any]=True     ,							SCREAMING_SNAKE_CASE__				:       Optional[Any]=False     ,							SCREAMING_SNAKE_CASE__				:       Dict=True     ,							SCREAMING_SNAKE_CASE__				:       Union[str, Any]=0     ,							SCREAMING_SNAKE_CASE__				:       Optional[int]=1     ,							**SCREAMING_SNAKE_CASE__				:       Dict     ,							)		->			Optional[Any]:
             a_					:		Optional[int]							=  vocab_size
             a_					:		List[str]							=  d_model
             a_					:		Tuple							=  d_kv
             a_					:		Optional[Any]							=  d_ff

             a_					:		List[Any]							=  num_sparse_encoder_layers

             a_					:		Any							=  num_layers
             a_					:		str							=  (
                 num_decoder_layers if num_decoder_layers is not None else self.num_layers
             )  # default = symmetry
             a_					:		List[Any]							=  num_sparse_decoder_layers

             # This tells us, each how many encoder layer we'll have to set a sparse layer.
             if self.num_sparse_encoder_layers > 0:
                    a_					:		Optional[int]							=  self.num_layers // self.num_sparse_encoder_layers
             else:
                    a_					:		List[Any]							=  self.num_layers  # HACK: this will create 0 sparse layers

             # This tells us, each how many encoder layer we'll have to set a sparse layer.
             if self.num_sparse_decoder_layers > 0:
                    a_					:		Union[str, Any]							=  self.num_decoder_layers // self.num_sparse_decoder_layers
             else:
                    a_					:		List[str]							=  self.num_decoder_layers  # HACK: this will create 0 sparse layers

             a_					:		Dict							=  num_heads
             a_					:		str							=  num_experts
             a_					:		Any							=  expert_capacity
             a_					:		List[Any]							=  router_bias
             a_					:		str							=  router_jitter_noise
             if router_dtype not in ["float32", "float16", "bfloat16"]:
                    raise ValueError(F"""`router_dtype` must be one of 'float32', 'float16' or 'bfloat16', got {router_dtype}"""     )
             a_					:		Optional[int]							=  router_dtype

             a_					:		int							=  router_ignore_padding_tokens
             a_					:		Any							=  relative_attention_num_buckets
             a_					:		List[str]							=  relative_attention_max_distance

             a_					:		Optional[Any]							=  dropout_rate
             a_					:		Tuple							=  layer_norm_epsilon
             a_					:		Dict							=  initializer_factor
             a_					:		Any							=  feed_forward_proj
             a_					:		Tuple							=  use_cache
             a_					:		str							=  add_router_probs

             a_					:		Optional[int]							=  router_z_loss_coef
             a_					:		List[str]							=  router_aux_loss_coef

             a_					:		int							=  self.feed_forward_proj.split('-'     )
             a_					:		int							=  act_info[-1]
             a_					:		Optional[int]							=  act_info[0] == 'gated'

             if len(SCREAMING_SNAKE_CASE__     ) > 1 and act_info[0] != "gated" or len(SCREAMING_SNAKE_CASE__     ) > 2:
                    raise ValueError(
                        F"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."""
                        'Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. '
                        '\'gated-gelu\' or \'relu\''     )

             # for backwards compatibility
             if feed_forward_proj == "gated-gelu":
                    a_					:		Any							=  'gelu_new'

             super().__init__(
                 pad_token_id=SCREAMING_SNAKE_CASE__     ,							eos_token_id=SCREAMING_SNAKE_CASE__     ,							is_encoder_decoder=SCREAMING_SNAKE_CASE__     ,							**SCREAMING_SNAKE_CASE__     ,							)


