

'''simple docstring'''






from dataclasses import dataclass
from typing import Optional

import numpy as np
import torch
import torch.nn as nn

from ..utils import BaseOutput, is_torch_version, randn_tensor
from .attention_processor import SpatialNorm
from .unet_ad_blocks import UNetMidBlockaD, get_down_block, get_up_block






@dataclass
class 			lowercase_	(lowerCamelCase__      ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE    :  torch.FloatTensor






class 			lowercase_	(nn.Module      ):




  """simple docstring"""




  def __init__(      self   :     str					,lowercase__   :     Tuple=3					,lowercase__   :     List[str]=3					,lowercase__   :     str=("DownEncoderBlock2D",)					,lowercase__   :     List[str]=(6_4,)					,lowercase__   :     List[str]=2					,lowercase__   :     Optional[Any]=3_2					,lowercase__   :     List[str]="silu"					,lowercase__   :     List[str]=True					,):
   super().__init__()
   __lowercase							  = layers_per_block

   __lowercase							  = torch.nn.Convad(
       lowercase__					,block_out_channels[0]					,kernel_size=3					,stride=1					,padding=1					,)

   __lowercase							  = None
   __lowercase							  = nn.ModuleList([]			)

   # down
   __lowercase							  = block_out_channels[0]
   for i, down_block_type in enumerate(lowercase__			):
    __lowercase							  = output_channel
    __lowercase							  = block_out_channels[i]
    __lowercase							  = i == len(lowercase__			) - 1

    __lowercase							  = get_down_block(
        lowercase__					,num_layers=self.layers_per_block					,in_channels=lowercase__					,out_channels=lowercase__					,add_downsample=not is_final_block					,resnet_eps=1e-6					,downsample_padding=0					,resnet_act_fn=lowercase__					,resnet_groups=lowercase__					,attention_head_dim=lowercase__					,temb_channels=lowercase__					,)
    self.down_blocks.append(lowercase__			)

   # mid
   __lowercase							  = UNetMidBlockaD(
       in_channels=block_out_channels[-1]					,resnet_eps=1e-6					,resnet_act_fn=lowercase__					,output_scale_factor=1					,resnet_time_scale_shift='''default'''					,attention_head_dim=block_out_channels[-1]					,resnet_groups=lowercase__					,temb_channels=lowercase__					,)

   # out
   __lowercase							  = nn.GroupNorm(num_channels=block_out_channels[-1]					,num_groups=lowercase__					,eps=1e-6			)
   __lowercase							  = nn.SiLU()

   __lowercase							  = 2 * out_channels if double_z else out_channels
   __lowercase							  = nn.Convad(block_out_channels[-1]					,lowercase__					,3					,padding=1			)

   __lowercase							  = False






  def 					SCREAMING_SNAKE_CASE      (      self   :     Any					,lowercase__   :     Any			):
   __lowercase							  = x
   __lowercase							  = self.conv_in(lowercase__			)

   if self.training and self.gradient_checkpointing:

    def create_custom_forward(lowercase__   :     List[Any]			):
     def custom_forward(*lowercase__   :     Dict			):
      return module(*lowercase__			)

     return custom_forward

    # down
    if is_torch_version('''>='''					,'''1.11.0'''			):
     for down_block in self.down_blocks:
      __lowercase							  = torch.utils.checkpoint.checkpoint(
          create_custom_forward(lowercase__			)					,lowercase__					,use_reentrant=lowercase__			)
     # middle
     __lowercase							  = torch.utils.checkpoint.checkpoint(
         create_custom_forward(self.mid_block			)					,lowercase__					,use_reentrant=lowercase__			)
    else:
     for down_block in self.down_blocks:
      __lowercase							  = torch.utils.checkpoint.checkpoint(create_custom_forward(lowercase__			)					,lowercase__			)
     # middle
     __lowercase							  = torch.utils.checkpoint.checkpoint(create_custom_forward(self.mid_block			)					,lowercase__			)

   else:
    # down
    for down_block in self.down_blocks:
     __lowercase							  = down_block(lowercase__			)

    # middle
    __lowercase							  = self.mid_block(lowercase__			)

   # post-process
   __lowercase							  = self.conv_norm_out(lowercase__			)
   __lowercase							  = self.conv_act(lowercase__			)
   __lowercase							  = self.conv_out(lowercase__			)

   return sample






class 			lowercase_	(nn.Module      ):




  """simple docstring"""




  def __init__(      self   :     str					,lowercase__   :     Optional[Any]=3					,lowercase__   :     Any=3					,lowercase__   :     Union[str, Any]=("UpDecoderBlock2D",)					,lowercase__   :     Any=(6_4,)					,lowercase__   :     str=2					,lowercase__   :     Optional[int]=3_2					,lowercase__   :     Tuple="silu"					,lowercase__   :     Union[str, Any]="group"					,):
   super().__init__()
   __lowercase							  = layers_per_block

   __lowercase							  = nn.Convad(
       lowercase__					,block_out_channels[-1]					,kernel_size=3					,stride=1					,padding=1					,)

   __lowercase							  = None
   __lowercase							  = nn.ModuleList([]			)

   __lowercase							  = in_channels if norm_type == '''spatial''' else None

   # mid
   __lowercase							  = UNetMidBlockaD(
       in_channels=block_out_channels[-1]					,resnet_eps=1e-6					,resnet_act_fn=lowercase__					,output_scale_factor=1					,resnet_time_scale_shift='''default''' if norm_type == '''group''' else norm_type					,attention_head_dim=block_out_channels[-1]					,resnet_groups=lowercase__					,temb_channels=lowercase__					,)

   # up
   __lowercase							  = list(reversed(lowercase__			)			)
   __lowercase							  = reversed_block_out_channels[0]
   for i, up_block_type in enumerate(lowercase__			):
    __lowercase							  = output_channel
    __lowercase							  = reversed_block_out_channels[i]

    __lowercase							  = i == len(lowercase__			) - 1

    __lowercase							  = get_up_block(
        lowercase__					,num_layers=self.layers_per_block + 1					,in_channels=lowercase__					,out_channels=lowercase__					,prev_output_channel=lowercase__					,add_upsample=not is_final_block					,resnet_eps=1e-6					,resnet_act_fn=lowercase__					,resnet_groups=lowercase__					,attention_head_dim=lowercase__					,temb_channels=lowercase__					,resnet_time_scale_shift=lowercase__					,)
    self.up_blocks.append(lowercase__			)
    __lowercase							  = output_channel

   # out
   if norm_type == "spatial":
    __lowercase							  = SpatialNorm(block_out_channels[0]					,lowercase__			)
   else:
    __lowercase							  = nn.GroupNorm(num_channels=block_out_channels[0]					,num_groups=lowercase__					,eps=1e-6			)
   __lowercase							  = nn.SiLU()
   __lowercase							  = nn.Convad(block_out_channels[0]					,lowercase__					,3					,padding=1			)

   __lowercase							  = False






  def 					SCREAMING_SNAKE_CASE      (      self   :     str					,lowercase__   :     Optional[Any]					,lowercase__   :     List[Any]=None			):
   __lowercase							  = z
   __lowercase							  = self.conv_in(lowercase__			)

   __lowercase							  = next(iter(self.up_blocks.parameters()			)			).dtype
   if self.training and self.gradient_checkpointing:

    def create_custom_forward(lowercase__   :     str			):
     def custom_forward(*lowercase__   :     List[Any]			):
      return module(*lowercase__			)

     return custom_forward

    if is_torch_version('''>='''					,'''1.11.0'''			):
     # middle
     __lowercase							  = torch.utils.checkpoint.checkpoint(
         create_custom_forward(self.mid_block			)					,lowercase__					,lowercase__					,use_reentrant=lowercase__			)
     __lowercase							  = sample.to(lowercase__			)

     # up
     for up_block in self.up_blocks:
      __lowercase							  = torch.utils.checkpoint.checkpoint(
          create_custom_forward(lowercase__			)					,lowercase__					,lowercase__					,use_reentrant=lowercase__			)
    else:
     # middle
     __lowercase							  = torch.utils.checkpoint.checkpoint(
         create_custom_forward(self.mid_block			)					,lowercase__					,lowercase__			)
     __lowercase							  = sample.to(lowercase__			)

     # up
     for up_block in self.up_blocks:
      __lowercase							  = torch.utils.checkpoint.checkpoint(create_custom_forward(lowercase__			)					,lowercase__					,lowercase__			)
   else:
    # middle
    __lowercase							  = self.mid_block(lowercase__					,lowercase__			)
    __lowercase							  = sample.to(lowercase__			)

    # up
    for up_block in self.up_blocks:
     __lowercase							  = up_block(lowercase__					,lowercase__			)

        # post-process
   if latent_embeds is None:
    __lowercase							  = self.conv_norm_out(lowercase__			)
   else:
    __lowercase							  = self.conv_norm_out(lowercase__					,lowercase__			)
   __lowercase							  = self.conv_act(lowercase__			)
   __lowercase							  = self.conv_out(lowercase__			)

   return sample






class 			lowercase_	(nn.Module      ):




  """simple docstring"""




  def __init__(      self   :     int					,lowercase__   :     str					,lowercase__   :     List[Any]					,lowercase__   :     str					,lowercase__   :     int=None					,lowercase__   :     int="random"					,lowercase__   :     Tuple=False					,lowercase__   :     List[str]=True			):
   super().__init__()
   __lowercase							  = n_e
   __lowercase							  = vq_embed_dim
   __lowercase							  = beta
   __lowercase							  = legacy

   __lowercase							  = nn.Embedding(self.n_e					,self.vq_embed_dim			)
   self.embedding.weight.data.uniform_(-1.0 / self.n_e					,1.0 / self.n_e			)

   __lowercase							  = remap
   if self.remap is not None:
    self.register_buffer('''used'''					,torch.tensor(np.load(self.remap			)			)			)
    __lowercase							  = self.used.shape[0]
    __lowercase							  = unknown_index  # "random" or "extra" or integer
    if self.unknown_index == "extra":
     __lowercase							  = self.re_embed
     __lowercase							  = self.re_embed + 1
    print(
        F"Remapping {self.n_e} indices to {self.re_embed} indices. "
        F"Using {self.unknown_index} for unknown indices."			)
   else:
    __lowercase							  = n_e

   __lowercase							  = sane_index_shape






  def 					SCREAMING_SNAKE_CASE      (      self   :     List[str]					,lowercase__   :     List[Any]			):
   __lowercase							  = inds.shape
   assert len(lowercase__			) > 1
   __lowercase							  = inds.reshape(ishape[0]					,-1			)
   __lowercase							  = self.used.to(lowercase__			)
   __lowercase							  = (inds[:, :, None] == used[None, None, ...]).long()
   __lowercase							  = match.argmax(-1			)
   __lowercase							  = match.sum(2			) < 1
   if self.unknown_index == "random":
    __lowercase							  = torch.randint(0					,self.re_embed					,size=new[unknown].shape			).to(device=new.device			)
   else:
    __lowercase							  = self.unknown_index
   return new.reshape(lowercase__			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict					,lowercase__   :     Any			):
   __lowercase							  = inds.shape
   assert len(lowercase__			) > 1
   __lowercase							  = inds.reshape(ishape[0]					,-1			)
   __lowercase							  = self.used.to(lowercase__			)
   if self.re_embed > self.used.shape[0]:  # extra token
    __lowercase							  = 0  # simply set to zero
   __lowercase							  = torch.gather(used[None, :][inds.shape[0] * [0], :]					,1					,lowercase__			)
   return back.reshape(lowercase__			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]					,lowercase__   :     Tuple			):
   # reshape z -> (batch, height, width, channel) and flatten
   __lowercase							  = z.permute(0					,2					,3					,1			).contiguous()
   __lowercase							  = z.view(-1					,self.vq_embed_dim			)

   # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
   __lowercase							  = torch.argmin(torch.cdist(lowercase__					,self.embedding.weight			)					,dim=1			)

   __lowercase							  = self.embedding(lowercase__			).view(z.shape			)
   __lowercase							  = None
   __lowercase							  = None

   # compute loss for embedding
   if not self.legacy:
    __lowercase							  = self.beta * torch.mean((z_q.detach() - z) ** 2			) + torch.mean((z_q - z.detach()) ** 2			)
   else:
    __lowercase							  = torch.mean((z_q.detach() - z) ** 2			) + self.beta * torch.mean((z_q - z.detach()) ** 2			)

   # preserve gradients
   __lowercase							  = z + (z_q - z).detach()

   # reshape back to match original input shape
   __lowercase							  = z_q.permute(0					,3					,1					,2			).contiguous()

   if self.remap is not None:
    __lowercase							  = min_encoding_indices.reshape(z.shape[0]					,-1			)  # add batch axis
    __lowercase							  = self.remap_to_used(lowercase__			)
    __lowercase							  = min_encoding_indices.reshape(-1					,1			)  # flatten

   if self.sane_index_shape:
    __lowercase							  = min_encoding_indices.reshape(z_q.shape[0]					,z_q.shape[2]					,z_q.shape[3]			)

   return z_q, loss, (perplexity, min_encodings, min_encoding_indices)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict					,lowercase__   :     List[Any]					,lowercase__   :     List[str]			):
   # shape specifying (batch, height, width, channel)
   if self.remap is not None:
    __lowercase							  = indices.reshape(shape[0]					,-1			)  # add batch axis
    __lowercase							  = self.unmap_to_all(lowercase__			)
    __lowercase							  = indices.reshape(-1			)  # flatten again

   # get quantized latent vectors
   __lowercase							  = self.embedding(lowercase__			)

   if shape is not None:
    __lowercase							  = z_q.view(lowercase__			)
    # reshape back to match original input shape
    __lowercase							  = z_q.permute(0					,3					,1					,2			).contiguous()

   return z_q






class 			lowercase_	(lowerCamelCase__      ):




  """simple docstring"""




  def __init__(      self   :     str					,lowercase__   :     Union[str, Any]					,lowercase__   :     Union[str, Any]=False			):
   __lowercase							  = parameters
   __lowercase  ,	__lowercase							  = torch.chunk(lowercase__					,2					,dim=1			)
   __lowercase							  = torch.clamp(self.logvar					,-3_0.0					,2_0.0			)
   __lowercase							  = deterministic
   __lowercase							  = torch.exp(0.5 * self.logvar			)
   __lowercase							  = torch.exp(self.logvar			)
   if self.deterministic:
    __lowercase							  = __lowercase							  = torch.zeros_like(
        self.mean					,device=self.parameters.device					,dtype=self.parameters.dtype			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Union[str, Any]					,lowercase__   :     Optional[torch.Generator] = None			):
   # make sure sample is on the same device as the parameters and has same dtype
   __lowercase							  = randn_tensor(
       self.mean.shape					,generator=lowercase__					,device=self.parameters.device					,dtype=self.parameters.dtype			)
   __lowercase							  = self.mean + self.std * sample
   return x






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict					,lowercase__   :     Any=None			):
   if self.deterministic:
    return torch.Tensor([0.0]			)
   else:
    if other is None:
     return 0.5 * torch.sum(torch.pow(self.mean					,2			) + self.var - 1.0 - self.logvar					,dim=[1, 2, 3]			)
    else:
     return 0.5 * torch.sum(
         torch.pow(self.mean - other.mean					,2			) / other.var
         + self.var / other.var
         - 1.0
         - self.logvar
         + other.logvar					,dim=[1, 2, 3]					,)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple					,lowercase__   :     List[str]					,lowercase__   :     str=[1, 2, 3]			):
   if self.deterministic:
    return torch.Tensor([0.0]			)
   __lowercase							  = np.log(2.0 * np.pi			)
   return 0.5 * torch.sum(logtwopi + self.logvar + torch.pow(sample - self.mean					,2			) / self.var					,dim=lowercase__			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     str			):
   return self.mean








"""simple docstring"""





import pickle
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, XGLMTokenizer, XGLMTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__A											=		get_tests_dir("""fixtures/test_sentencepiece.model""")






@require_sentencepiece
@require_tokenizers
class 					_lowerCAmelCase   (     a  ,   unittest.TestCase       ):
       """simple docstring"""




       __magic_name__     :List[str]		  =					XGLMTokenizer
       __magic_name__     :Any		  =					XGLMTokenizerFast
       __magic_name__     :Dict		  =					True
       __magic_name__     :Union[str, Any]		  =					True






       def      snake_case						(    self      ):



         '''simple docstring'''

         super().setUp()

         # We have a SentencePiece fixture for testing
         lowerCAmelCase__			:int											=							XGLMTokenizer(__UpperCAmelCase    , keep_accents=__UpperCAmelCase      )
         tokenizer.save_pretrained(self.tmpdirname      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[Any]											=							'<pad>'
         lowerCAmelCase__			:int											=							1

         self.assertEqual(self.get_tokenizer()._convert_token_to_id(__UpperCAmelCase      )    , __UpperCAmelCase      )
         self.assertEqual(self.get_tokenizer()._convert_id_to_token(__UpperCAmelCase      )    , __UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[int]											=							list(self.get_tokenizer().get_vocab().keys()      )

         self.assertEqual(vocab_keys[0]    , '<s>'      )
         self.assertEqual(vocab_keys[1]    , '<pad>'      )
         self.assertEqual(len(__UpperCAmelCase      )    , 1_0_0_8      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         self.assertEqual(self.get_tokenizer().vocab_size    , 1_0_0_8      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[Any]											=							XGLMTokenizer(__UpperCAmelCase    , keep_accents=__UpperCAmelCase      )

         lowerCAmelCase__			:Optional[Any]											=							tokenizer.tokenize('This is a test'      )
         self.assertListEqual(__UpperCAmelCase    , ['▁This', '▁is', '▁a', '▁t', 'est']      )

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(__UpperCAmelCase      )    , [value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]    , )

         lowerCAmelCase__			:int											=							tokenizer.tokenize('I was born in 92000, and this is falsé.'      )
         self.assertListEqual(
             __UpperCAmelCase    , [
                 SPIECE_UNDERLINE + 'I',
                 SPIECE_UNDERLINE + 'was',
                 SPIECE_UNDERLINE + 'b',
                 'or',
                 'n',
                 SPIECE_UNDERLINE + 'in',
                 SPIECE_UNDERLINE + '',
                 '9',
                 '2',
                 '0',
                 '0',
                 '0',
                 ',',
                 SPIECE_UNDERLINE + 'and',
                 SPIECE_UNDERLINE + 'this',
                 SPIECE_UNDERLINE + 'is',
                 SPIECE_UNDERLINE + 'f',
                 'al',
                 's',
                 'é',
                 '.',
             ]    , )
         lowerCAmelCase__			:Tuple											=							tokenizer.convert_tokens_to_ids(__UpperCAmelCase      )
         self.assertListEqual(
             __UpperCAmelCase    , [
                 value + tokenizer.fairseq_offset
                 for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
             ]    , )

         lowerCAmelCase__			:Optional[int]											=							tokenizer.convert_ids_to_tokens(__UpperCAmelCase      )
         self.assertListEqual(
             __UpperCAmelCase    , [
                 SPIECE_UNDERLINE + 'I',
                 SPIECE_UNDERLINE + 'was',
                 SPIECE_UNDERLINE + 'b',
                 'or',
                 'n',
                 SPIECE_UNDERLINE + 'in',
                 SPIECE_UNDERLINE + '',
                 '<unk>',
                 '2',
                 '0',
                 '0',
                 '0',
                 ',',
                 SPIECE_UNDERLINE + 'and',
                 SPIECE_UNDERLINE + 'this',
                 SPIECE_UNDERLINE + 'is',
                 SPIECE_UNDERLINE + 'f',
                 'al',
                 's',
                 '<unk>',
                 '.',
             ]    , )






       @cached_property
       def      snake_case						(    self      ):



         '''simple docstring'''

         return XGLMTokenizer.from_pretrained('facebook/xglm-564M'      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         with tempfile.NamedTemporaryFile() as f:
           shutil.copyfile(__UpperCAmelCase    , f.name      )
           lowerCAmelCase__			:Dict											=							XGLMTokenizer(f.name    , keep_accents=__UpperCAmelCase      )
           lowerCAmelCase__			:List[Any]											=							pickle.dumps(__UpperCAmelCase      )
         pickle.loads(__UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         if not self.test_rust_tokenizer:
           return

         lowerCAmelCase__			:Optional[Any]											=							self.get_tokenizer()
         lowerCAmelCase__			:List[str]											=							self.get_rust_tokenizer()

         lowerCAmelCase__			:Optional[Any]											=							'I was born in 92000, and this is falsé.'

         lowerCAmelCase__			:Dict											=							tokenizer.tokenize(__UpperCAmelCase      )
         lowerCAmelCase__			:Union[str, Any]											=							rust_tokenizer.tokenize(__UpperCAmelCase      )
         self.assertListEqual(__UpperCAmelCase    , __UpperCAmelCase      )

         lowerCAmelCase__			:Optional[Any]											=							tokenizer.encode(__UpperCAmelCase    , add_special_tokens=__UpperCAmelCase      )
         lowerCAmelCase__			:List[Any]											=							rust_tokenizer.encode(__UpperCAmelCase    , add_special_tokens=__UpperCAmelCase      )
         self.assertListEqual(__UpperCAmelCase    , __UpperCAmelCase      )

         lowerCAmelCase__			:int											=							self.get_rust_tokenizer()
         lowerCAmelCase__			:Dict											=							tokenizer.encode(__UpperCAmelCase      )
         lowerCAmelCase__			:Tuple											=							rust_tokenizer.encode(__UpperCAmelCase      )
         self.assertListEqual(__UpperCAmelCase    , __UpperCAmelCase      )






       @slow
       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:str											=							'Hello World!'
         lowerCAmelCase__			:Tuple											=							[2, 3_1_2_2_7, 4_4_4_7, 3_5]

         self.assertListEqual(__UpperCAmelCase    , self.big_tokenizer.encode(__UpperCAmelCase      )      )






       @slow
       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Tuple											=							(
             'This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'
             ' add words that should not exsist and be tokenized to unk, such as saoneuhaoesuth'
         )
         # fmt: off
         lowerCAmelCase__			:List[str]											=							[2, 1_0_1_8, 6_7, 1_1, 1_9_8_8, 2_6_1_7, 5_6_3_1, 2_7_8, 1_1, 3_4_0_7, 4_8, 7_1_6_3_0, 2_8_0_8_5, 4, 3_2_3_4, 1_5_7, 1_3, 6, 5, 6, 4, 3_5_2_6, 7_6_8, 1_5, 6_5_9, 5_7, 2_9_8, 3_9_8_3, 8_6_4, 1_2_9, 2_1, 6, 5, 1_3_6_7_5, 3_7_7, 6_5_2, 7_5_8_0, 1_0_3_4_1, 1_5_5, 2_8_1_7, 4_2_2, 1_6_6_6, 7, 1_6_7_4, 5_3, 1_1_3, 2_0_2_2_7_7, 1_7_8_9_2, 3_3, 6_0, 8_7, 4, 3_2_3_4, 1_5_7, 6_1, 2_6_6_7, 5_2_3_7_6, 1_9, 8_8, 2_3, 7_3_5]
         # fmt: on

         self.assertListEqual(__UpperCAmelCase    , self.big_tokenizer.encode(__UpperCAmelCase      )      )






       @slow
       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Union[str, Any]											=							{
             'input_ids': [[2, 1_0_8_8_2_5, 1_1_6_3, 1_5, 8_8_0_1_0, 4_7_3, 1_5_8_9_8, 1_5_7, 1_3_6_7_2, 1_8_5_7, 3_1_2, 8, 2_3_8_0_2_1, 1_1_6_3, 5_3, 1_3_6_7_2, 1_8_5_7, 3_1_2, 8, 5_3_2_8_3, 1_8_2_3_9_6, 8, 1_8_5_6_6, 1_6, 3_6_7_3_3, 4_1_0_1, 8, 2_3_0, 2_4_4_0_1_7, 1_2_2_5_5_3, 7, 1_5, 1_3_2_5_9_7, 4, 2_9_3, 1_2_5_1_1, 7_6_1_0, 4, 3_4_1_4, 1_3_2_5_9_7, 9, 4, 3_2_3_6_1, 3_6_2, 4, 7_3_4, 2_8_5_1_2, 3_2_5_6_9, 1_8, 4, 3_2_3_6_1, 2_6_0_9_6, 1_4_9_8_2, 7_3, 1_8_7_1_5, 2_1_4_3_3, 2_3_5_2_6_1, 1_5, 4_9_2, 1_2_4_2_7, 1_6, 5_3, 1_8_7_1_5, 2_1_4_3_3, 6_5_4_5_4, 1_5, 2_3_6_5_9, 5_6_3, 1_6, 2_7_8, 5_9_7, 2_8_4_3, 5_9_5, 7_9_3_1, 1_8_2_3_9_6, 6_4_1_8_6, 2_2, 8_8_6, 5_9_5, 1_3_2_9_8_1, 5_3, 2_5_5_4_0, 3_4_4_9, 4_3_9_8_2, 3_9_9_0_1, 5_9_5_1, 8_7_8, 3_3_0, 4, 2_7_6_9_4, 8_0_2_6_9, 3_1_2, 5_3, 6_5_1_7, 1_1_7_8_0, 6_1_1, 2_0_4_0_8, 5], [2, 6, 1_3_2_5_9_7, 6_7, 4_2_8_9_7, 3_3, 5_9_2, 8, 1_6_3_7_2_9, 2_5_5_4_0, 3_6_1, 1_3_6_9_9_7, 1_0_9_5_1_4, 1_7_3_2_3_0, 7, 5_0_1, 6_0, 1_0_2_9_1_3, 1_9_6, 5_6_3_1, 2_3_5, 6_3_2_4_3, 4_7_3, 6, 2_3_1_7_5_7, 7_4, 5_2_7_7, 7_9_0_5, 5_3, 3_0_9_5, 3_7_3_1_7, 2_2, 4_5_4, 1_8_3_8_7_4, 5], [2, 2_6_8, 3_1_2_9_8, 4_6_5_3_0, 6, 1_3_2_9_3_5, 4_3_8_3_1, 7, 5_9_7, 3_2, 2_4, 3_6_8_8, 9_8_6_5, 5]],
             'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
         }  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=__UpperCAmelCase    , model_name='facebook/xglm-564M'    , padding=__UpperCAmelCase    , )
