
import argparse
import os.path as osp
import re

import torch
from safetensors.torch import load_file, save_file


# =================#
# UNet Conversion #
# =================#

lowercase__       =[
    # (stable-diffusion, HF Diffusers)
    ('time_embed.0.weight', 'time_embedding.linear_1.weight'),
    ('time_embed.0.bias', 'time_embedding.linear_1.bias'),
    ('time_embed.2.weight', 'time_embedding.linear_2.weight'),
    ('time_embed.2.bias', 'time_embedding.linear_2.bias'),
    ('input_blocks.0.0.weight', 'conv_in.weight'),
    ('input_blocks.0.0.bias', 'conv_in.bias'),
    ('out.0.weight', 'conv_norm_out.weight'),
    ('out.0.bias', 'conv_norm_out.bias'),
    ('out.2.weight', 'conv_out.weight'),
    ('out.2.bias', 'conv_out.bias'),
]

lowercase__       =[
    # (stable-diffusion, HF Diffusers)
    ('in_layers.0', 'norm1'),
    ('in_layers.2', 'conv1'),
    ('out_layers.0', 'norm2'),
    ('out_layers.3', 'conv2'),
    ('emb_layers.1', 'time_emb_proj'),
    ('skip_connection', 'conv_shortcut'),
]

lowercase__       =[]
# hardcoded number of downblocks and resnets/attentions...
# would need smarter logic for other networks.
for i in range(4):
      # loop over downblocks/upblocks

      for j in range(2):
            # loop over resnets/attentions for downblocks
            lowercase__       =F"""down_blocks.{i}.resnets.{j}."""
            lowercase__       =F"""input_blocks.{3*i + j + 1}.0."""
            unet_conversion_map_layer.append((sd_down_res_prefix, hf_down_res_prefix))

            if i < 3:
                  # no attention layers in down_blocks.3
                  lowercase__       =F"""down_blocks.{i}.attentions.{j}."""
                  lowercase__       =F"""input_blocks.{3*i + j + 1}.1."""
                  unet_conversion_map_layer.append((sd_down_atn_prefix, hf_down_atn_prefix))

      for j in range(3):
            # loop over resnets/attentions for upblocks
            lowercase__       =F"""up_blocks.{i}.resnets.{j}."""
            lowercase__       =F"""output_blocks.{3*i + j}.0."""
            unet_conversion_map_layer.append((sd_up_res_prefix, hf_up_res_prefix))

            if i > 0:
                  # no attention layers in up_blocks.0
                  lowercase__       =F"""up_blocks.{i}.attentions.{j}."""
                  lowercase__       =F"""output_blocks.{3*i + j}.1."""
                  unet_conversion_map_layer.append((sd_up_atn_prefix, hf_up_atn_prefix))

      if i < 3:
            # no downsample in down_blocks.3
            lowercase__       =F"""down_blocks.{i}.downsamplers.0.conv."""
            lowercase__       =F"""input_blocks.{3*(i+1)}.0.op."""
            unet_conversion_map_layer.append((sd_downsample_prefix, hf_downsample_prefix))

            # no upsample in up_blocks.3
            lowercase__       =F"""up_blocks.{i}.upsamplers.0."""
            lowercase__       =F"""output_blocks.{3*i + 2}.{1 if i == 0 else 2}."""
            unet_conversion_map_layer.append((sd_upsample_prefix, hf_upsample_prefix))

lowercase__       ='mid_block.attentions.0.'
lowercase__       ='middle_block.1.'
unet_conversion_map_layer.append((sd_mid_atn_prefix, hf_mid_atn_prefix))

for j in range(2):
      lowercase__       =F"""mid_block.resnets.{j}."""
      lowercase__       =F"""middle_block.{2*j}."""
      unet_conversion_map_layer.append((sd_mid_res_prefix, hf_mid_res_prefix))




def    __UpperCamelCase     (				lowerCAmelCase__							:				Any  ):
 __a :  Optional[Any]						=  {k: k for k in unet_state_dict.keys()}
 for sd_name, hf_name in unet_conversion_map:
  __a :  Dict						=  sd_name
 for k, v in mapping.items():
  if "resnets" in k:
   for sd_part, hf_part in unet_conversion_map_resnet:
    __a :  Dict						=  v.replace(__lowerCAmelCase  ,   __lowerCAmelCase  )
   __a :  Any						=  v
 for k, v in mapping.items():
  for sd_part, hf_part in unet_conversion_map_layer:
   __a :  Any						=  v.replace(__lowerCAmelCase  ,   __lowerCAmelCase  )
  __a :  int						=  v
 __a :  Optional[int]						=  {v: unet_state_dict[k] for k, v in mapping.items()}
 return new_state_dict


# ================#
# VAE Conversion #
# ================#

lowercase__       =[
    # (stable-diffusion, HF Diffusers)
    ('nin_shortcut', 'conv_shortcut'),
    ('norm_out', 'conv_norm_out'),
    ('mid.attn_1.', 'mid_block.attentions.0.'),
]

for i in range(4):
      # down_blocks have two resnets
      for j in range(2):
            lowercase__       =F"""encoder.down_blocks.{i}.resnets.{j}."""
            lowercase__       =F"""encoder.down.{i}.block.{j}."""
            vae_conversion_map.append((sd_down_prefix, hf_down_prefix))

      if i < 3:
            lowercase__       =F"""down_blocks.{i}.downsamplers.0."""
            lowercase__       =F"""down.{i}.downsample."""
            vae_conversion_map.append((sd_downsample_prefix, hf_downsample_prefix))

            lowercase__       =F"""up_blocks.{i}.upsamplers.0."""
            lowercase__       =F"""up.{3-i}.upsample."""
            vae_conversion_map.append((sd_upsample_prefix, hf_upsample_prefix))

      # up_blocks have three resnets
      # also, up blocks in hf are numbered in reverse from sd
      for j in range(3):
            lowercase__       =F"""decoder.up_blocks.{i}.resnets.{j}."""
            lowercase__       =F"""decoder.up.{3-i}.block.{j}."""
            vae_conversion_map.append((sd_up_prefix, hf_up_prefix))

# this part accounts for mid blocks in both the encoder and the decoder
for i in range(2):
      lowercase__       =F"""mid_block.resnets.{i}."""
      lowercase__       =F"""mid.block_{i+1}."""
      vae_conversion_map.append((sd_mid_res_prefix, hf_mid_res_prefix))


lowercase__       =[
    # (stable-diffusion, HF Diffusers)
    ('norm.', 'group_norm.'),
    ('q.', 'query.'),
    ('k.', 'key.'),
    ('v.', 'value.'),
    ('proj_out.', 'proj_attn.'),
]




def    __UpperCamelCase     (				lowerCAmelCase__							:				int  ):
 return w.reshape(*w.shape  ,   1  ,   1  )




def    __UpperCamelCase     (				lowerCAmelCase__							:				int  ):
 __a :  List[str]						=  {k: k for k in vae_state_dict.keys()}
 for k, v in mapping.items():
  for sd_part, hf_part in vae_conversion_map:
   __a :  int						=  v.replace(__lowerCAmelCase  ,   __lowerCAmelCase  )
  __a :  str						=  v
 for k, v in mapping.items():
  if "attentions" in k:
   for sd_part, hf_part in vae_conversion_map_attn:
    __a :  int						=  v.replace(__lowerCAmelCase  ,   __lowerCAmelCase  )
   __a :  Optional[Any]						=  v
 __a :  Optional[Any]						=  {v: vae_state_dict[k] for k, v in mapping.items()}
 __a :  int						=  ['''q''', '''k''', '''v''', '''proj_out''']
 for k, v in new_state_dict.items():
  for weight_name in weights_to_convert:
   if f"mid.attn_1.{weight_name}.weight" in k:
    print(f"Reshaping {k} for SD format"  )
    __a :  Union[str, Any]						=  reshape_weight_for_sd(__lowerCAmelCase  )
 return new_state_dict


# =========================#
# Text Encoder Conversion #
# =========================#


lowercase__       =[
    # (stable-diffusion, HF Diffusers)
    ('resblocks.', 'text_model.encoder.layers.'),
    ('ln_1', 'layer_norm1'),
    ('ln_2', 'layer_norm2'),
    ('.c_fc.', '.fc1.'),
    ('.c_proj.', '.fc2.'),
    ('.attn', '.self_attn'),
    ('ln_final.', 'transformer.text_model.final_layer_norm.'),
    ('token_embedding.weight', 'transformer.text_model.embeddings.token_embedding.weight'),
    ('positional_embedding', 'transformer.text_model.embeddings.position_embedding.weight'),
]
lowercase__       ={re.escape(x[1]): x[0] for x in textenc_conversion_lst}
lowercase__       =re.compile('|'.join(protected.keys()))

# Ordering is from https://github.com/pytorch/pytorch/blob/master/test/cpp/api/modules.cpp
lowercase__       ={'q': 0, 'k': 1, 'v': 2}




def    __UpperCamelCase     (				lowerCAmelCase__							:				str  ):
 __a :  str						=  {}
 __a :  str						=  {}
 __a :  Optional[int]						=  {}
 for k, v in text_enc_dict.items():
  if (
      k.endswith('''.self_attn.q_proj.weight'''  )
      or k.endswith('''.self_attn.k_proj.weight'''  )
      or k.endswith('''.self_attn.v_proj.weight'''  )
  ):
   __a :  List[str]						=  k[: -len('''.q_proj.weight'''  )]
   __a :  Any						=  k[-len('''q_proj.weight'''  )]
   if k_pre not in capture_qkv_weight:
    __a :  Union[str, Any]						=  [None, None, None]
   __a :  Any						=  v
   continue

  if (
      k.endswith('''.self_attn.q_proj.bias'''  )
      or k.endswith('''.self_attn.k_proj.bias'''  )
      or k.endswith('''.self_attn.v_proj.bias'''  )
  ):
   __a :  Tuple						=  k[: -len('''.q_proj.bias'''  )]
   __a :  Dict						=  k[-len('''q_proj.bias'''  )]
   if k_pre not in capture_qkv_bias:
    __a :  Optional[int]						=  [None, None, None]
   __a :  int						=  v
   continue

  __a :  Tuple						=  textenc_pattern.sub(lambda lowerCAmelCase__  : protected[re.escape(m.group(0  )  )]  ,   __lowerCAmelCase  )
  __a :  List[str]						=  v

 for k_pre, tensors in capture_qkv_weight.items():
  if None in tensors:
   raise Exception('''CORRUPTED MODEL: one of the q-k-v values for the text encoder was missing'''  )
  __a :  Dict						=  textenc_pattern.sub(lambda lowerCAmelCase__  : protected[re.escape(m.group(0  )  )]  ,   __lowerCAmelCase  )
  __a :  Union[str, Any]						=  torch.cat(__lowerCAmelCase  )

 for k_pre, tensors in capture_qkv_bias.items():
  if None in tensors:
   raise Exception('''CORRUPTED MODEL: one of the q-k-v values for the text encoder was missing'''  )
  __a :  List[Any]						=  textenc_pattern.sub(lambda lowerCAmelCase__  : protected[re.escape(m.group(0  )  )]  ,   __lowerCAmelCase  )
  __a :  int						=  torch.cat(__lowerCAmelCase  )

 return new_state_dict




def    __UpperCamelCase     (				lowerCAmelCase__							:				int  ):
 return text_enc_dict


if __name__ == "__main__":
      lowercase__       =argparse.ArgumentParser()

      parser.add_argument('--model_path', default=None, type=str, required=True, help='Path to the model to convert.')
      parser.add_argument('--checkpoint_path', default=None, type=str, required=True, help='Path to the output model.')
      parser.add_argument('--half', action='store_true', help='Save weights in half precision.')
      parser.add_argument(
          '--use_safetensors', action='store_true', help='Save weights use safetensors, default is ckpt.'
      )

      lowercase__       =parser.parse_args()

      assert args.model_path is not None, "Must provide a model path!"

      assert args.checkpoint_path is not None, "Must provide a checkpoint path!"

      # Path for safetensors
      lowercase__       =osp.join(args.model_path, 'unet', 'diffusion_pytorch_model.safetensors')
      lowercase__       =osp.join(args.model_path, 'vae', 'diffusion_pytorch_model.safetensors')
      lowercase__       =osp.join(args.model_path, 'text_encoder', 'model.safetensors')

      # Load models from safetensors if it exists, if it doesn't pytorch
      if osp.exists(unet_path):
            lowercase__       =load_file(unet_path, device='cpu')
      else:
            lowercase__       =osp.join(args.model_path, 'unet', 'diffusion_pytorch_model.bin')
            lowercase__       =torch.load(unet_path, map_location='cpu')

      if osp.exists(vae_path):
            lowercase__       =load_file(vae_path, device='cpu')
      else:
            lowercase__       =osp.join(args.model_path, 'vae', 'diffusion_pytorch_model.bin')
            lowercase__       =torch.load(vae_path, map_location='cpu')

      if osp.exists(text_enc_path):
            lowercase__       =load_file(text_enc_path, device='cpu')
      else:
            lowercase__       =osp.join(args.model_path, 'text_encoder', 'pytorch_model.bin')
            lowercase__       =torch.load(text_enc_path, map_location='cpu')

      # Convert the UNet model
      lowercase__       =convert_unet_state_dict(unet_state_dict)
      lowercase__       ={'model.diffusion_model.' + k: v for k, v in unet_state_dict.items()}

      # Convert the VAE model
      lowercase__       =convert_vae_state_dict(vae_state_dict)
      lowercase__       ={'first_stage_model.' + k: v for k, v in vae_state_dict.items()}

      # Easiest way to identify v2.0 model seems to be that the text encoder (OpenCLIP) is deeper
      lowercase__       ='text_model.encoder.layers.22.layer_norm2.bias' in text_enc_dict

      if is_vaa_model:
            # Need to add the tag 'transformer' in advance so we can knock it out from the final layer-norm
            lowercase__       ={'transformer.' + k: v for k, v in text_enc_dict.items()}
            lowercase__       =convert_text_enc_state_dict_vaa(text_enc_dict)
            lowercase__       ={'cond_stage_model.model.' + k: v for k, v in text_enc_dict.items()}
      else:
            lowercase__       =convert_text_enc_state_dict(text_enc_dict)
            lowercase__       ={'cond_stage_model.transformer.' + k: v for k, v in text_enc_dict.items()}

      # Put together new checkpoint
      lowercase__       ={**unet_state_dict, **vae_state_dict, **text_enc_dict}
      if args.half:
            lowercase__       ={k: v.half() for k, v in state_dict.items()}

      if args.use_safetensors:
            save_file(state_dict, args.checkpoint_path)
      else:
            lowercase__       ={'state_dict': state_dict}
            torch.save(state_dict, args.checkpoint_path)








import unittest

from transformers import AlbertTokenizer, AlbertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_a      	=  get_tests_dir('''fixtures/spiece.model''')





@require_sentencepiece
@require_tokenizers
class __lowerCamelCase (      snake_case__     ,       unittest.TestCase):





	"""simple docstring"""






	UpperCamelCase__								=      AlbertTokenizer
	UpperCamelCase__								=      AlbertTokenizerFast
	UpperCamelCase__								=      True
	UpperCamelCase__								=      True
	UpperCamelCase__								=      True

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							super().setUp()

							# We have a SentencePiece fixture for testing
							_UpperCAmelCase									=			AlbertTokenizer(UpperCAmelCase    )
							tokenizer.save_pretrained(self.tmpdirname    )

	def        UpperCamelCase    (							self       ,    UpperCAmelCase    ):
							"""simple docstring"""







							_UpperCAmelCase									=			'this is a test'
							_UpperCAmelCase									=			'this is a test'
							return input_text, output_text

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			'<pad>'
							_UpperCAmelCase									=			0

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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			list(self.get_tokenizer().get_vocab().keys()    )

							self.assertEqual(vocab_keys[0]       ,    '<pad>'    )
							self.assertEqual(vocab_keys[1]       ,    '<unk>'    )
							self.assertEqual(vocab_keys[-1]       ,    '▁eloquent'    )
							self.assertEqual(len(UpperCAmelCase    )       ,    3_0000    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							self.assertEqual(self.get_tokenizer().vocab_size       ,    3_0000    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							if not self.test_rust_tokenizer:
													return

							_UpperCAmelCase									=			self.get_tokenizer()
							_UpperCAmelCase									=			self.get_rust_tokenizer()

							_UpperCAmelCase									=			'I was born in 92000, and this is falsé.'

							_UpperCAmelCase									=			tokenizer.tokenize(UpperCAmelCase    )
							_UpperCAmelCase									=			rust_tokenizer.tokenize(UpperCAmelCase    )
							self.assertListEqual(UpperCAmelCase       ,    UpperCAmelCase    )

							_UpperCAmelCase									=			tokenizer.encode(UpperCAmelCase       ,    add_special_tokens=UpperCAmelCase    )
							_UpperCAmelCase									=			rust_tokenizer.encode(UpperCAmelCase       ,    add_special_tokens=UpperCAmelCase    )
							self.assertListEqual(UpperCAmelCase       ,    UpperCAmelCase    )

							_UpperCAmelCase									=			self.get_rust_tokenizer()
							_UpperCAmelCase									=			tokenizer.encode(UpperCAmelCase    )
							_UpperCAmelCase									=			rust_tokenizer.encode(UpperCAmelCase    )
							self.assertListEqual(UpperCAmelCase       ,    UpperCAmelCase    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			AlbertTokenizer(UpperCAmelCase       ,    keep_accents=UpperCAmelCase    )

							_UpperCAmelCase									=			tokenizer.tokenize('This is a test'    )
							self.assertListEqual(UpperCAmelCase       ,    ['▁this', '▁is', '▁a', '▁test']    )

							self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase    )       ,    [48, 25, 21, 1289]    )

							_UpperCAmelCase									=			tokenizer.tokenize('I was born in 92000, and this is falsé.'    )
							self.assertListEqual(
							    UpperCAmelCase       ,    ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', 'é', '.']    )
							_UpperCAmelCase									=			tokenizer.convert_tokens_to_ids(UpperCAmelCase    )
							self.assertListEqual(UpperCAmelCase       ,    [31, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]    )

							_UpperCAmelCase									=			tokenizer.convert_ids_to_tokens(UpperCAmelCase    )
							self.assertListEqual(
							    UpperCAmelCase       ,    ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.']       ,    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			AlbertTokenizer(UpperCAmelCase    )

							_UpperCAmelCase									=			tokenizer.encode('sequence builders'    )
							_UpperCAmelCase									=			tokenizer.encode('multi-sequence build'    )

							_UpperCAmelCase									=			tokenizer.build_inputs_with_special_tokens(UpperCAmelCase    )
							_UpperCAmelCase									=			tokenizer.build_inputs_with_special_tokens(UpperCAmelCase       ,    UpperCAmelCase    )

							assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
							assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
							    tokenizer.sep_token_id
							]

	@slow
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			{'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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'input_ids': [[2, 2_1970, 13, 5, 6092, 167, 28, 7103, 2153, 673, 8, 7028, 1_2051, 18, 17, 7103, 2153, 673, 8, 3515, 1_8684, 8, 4461, 6, 1927, 297, 8, 1_2060, 2607, 18, 13, 5, 4461, 15, 1_0538, 38, 8, 135, 15, 822, 58, 15, 993, 1_0363, 15, 1460, 8005, 4461, 15, 993, 255, 2328, 9, 9, 9, 6, 26, 1112, 816, 3260, 13, 5, 103, 2377, 6, 17, 1112, 816, 2782, 13, 5, 103, 1_0641, 6, 29, 84, 2512, 2430, 782, 1_8684, 2761, 19, 808, 2430, 2556, 17, 855, 1480, 9477, 4091, 128, 1_1712, 15, 7103, 2153, 673, 17, 2_4883, 9990, 9, 3], [2, 1_1502, 25, 1006, 20, 782, 8, 1_1809, 855, 1732, 1_9393, 1_8667, 37, 367, 2_1018, 69, 1854, 34, 1_1860, 1_9124, 27, 156, 225, 17, 193, 4141, 19, 65, 9124, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 14, 2231, 886, 2385, 1_7659, 84, 14, 1_6792, 1952, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
							# fmt: on

							self.tokenizer_integration_test_util(
							    expected_encoding=UpperCAmelCase       ,    model_name='albert-base-v2'       ,    revision='6b6560eaf5ff2e250b00c50f380c5389a9c2d82e'       ,    )
