






import argparse
import os

import gluonnlp as nlp
import mxnet as mx
import numpy as np
import torch
from gluonnlp.base import get_home_dir
from gluonnlp.model.bert import BERTEncoder
from gluonnlp.model.utils import _load_vocab
from gluonnlp.vocab import Vocab
from packaging import version
from torch import nn

from transformers import BertConfig, BertForMaskedLM, BertModel, RobertaTokenizer
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.utils import logging


if version.parse(nlp.__version__) != version.parse('0.8.3'):
   raise Exception('requires gluonnlp == 0.8.3')

if version.parse(mx.__version__) != version.parse('1.5.0'):
   raise Exception('requires mxnet == 1.5.0')

logging.set_verbosity_info()
A_		:		int		     =			logging.get_logger(__name__)

A_		:		List[str]		     =			'The Nymphenburg Palace is a beautiful palace in Munich!'

def   snake_case (UpperCAmelCase__     ,   UpperCAmelCase__  )	->    List[Any]:
  UpperCamelCase_: str   				=    {
      'attention_cell': 'multi_head',
      'num_layers': 4,
      'units': 1_0_2_4,
      'hidden_size': 7_6_8,
      'max_length': 5_1_2,
      'num_heads': 8,
      'scaled': True,
      'dropout': 0.1,
      'use_residual': True,
      'embed_size': 1_0_2_4,
      'embed_dropout': 0.1,
      'word_embed': None,
      'layer_norm_eps': 1E-5,
      'token_type_vocab_size': 2,
  }

  UpperCamelCase_: Any   				=    bort_4_8_768_1024_hparams

  # Let's construct the original Bort model here
  # Taken from official BERT implementation, see:
  # https://github.com/alexa/bort/blob/master/bort/bort.py
  UpperCamelCase_: List[Any]   				=    BERTEncoder(
      attention_cell=predefined_args['attention_cell']     ,   num_layers=predefined_args['num_layers']     ,   units=predefined_args['units']     ,   hidden_size=predefined_args['hidden_size']     ,   max_length=predefined_args['max_length']     ,   num_heads=predefined_args['num_heads']     ,   scaled=predefined_args['scaled']     ,   dropout=predefined_args['dropout']     ,   output_attention=UpperCAmelCase__     ,   output_all_encodings=UpperCAmelCase__     ,   use_residual=predefined_args['use_residual']     ,   activation=predefined_args.get('activation'     ,   'gelu'  )     ,   layer_norm_eps=predefined_args.get('layer_norm_eps'     ,   UpperCAmelCase__  )     ,   )

  # Vocab information needs to be fetched first
  # It's the same as RoBERTa, so RobertaTokenizer can be used later
  UpperCamelCase_: Optional[Any]   				=    'openwebtext_ccnews_stories_books_cased'

  # Specify download folder to Gluonnlp's vocab
  UpperCamelCase_: List[Any]   				=    os.path.join(get_home_dir()     ,   'models'  )
  UpperCamelCase_: Optional[int]   				=    _load_vocab(UpperCAmelCase__     ,   UpperCAmelCase__     ,   UpperCAmelCase__     ,   cls=UpperCAmelCase__  )

  UpperCamelCase_: Tuple   				=    nlp.model.BERTModel(
      UpperCAmelCase__     ,   len(UpperCAmelCase__  )     ,   units=predefined_args['units']     ,   embed_size=predefined_args['embed_size']     ,   embed_dropout=predefined_args['embed_dropout']     ,   word_embed=predefined_args['word_embed']     ,   use_pooler=UpperCAmelCase__     ,   use_token_type_embed=UpperCAmelCase__     ,   token_type_vocab_size=predefined_args['token_type_vocab_size']     ,   use_classifier=UpperCAmelCase__     ,   use_decoder=UpperCAmelCase__     ,   )

  original_bort.load_parameters(UpperCAmelCase__     ,   cast_dtype=UpperCAmelCase__     ,   ignore_extra=UpperCAmelCase__  )
  UpperCamelCase_: str   				=    original_bort._collect_params_with_prefix()

  # Build our config 🤗
  UpperCamelCase_: Union[str, Any]   				=    {
      'architectures': ['BertForMaskedLM'],
      'attention_probs_dropout_prob': predefined_args['dropout'],
      'hidden_act': 'gelu',
      'hidden_dropout_prob': predefined_args['dropout'],
      'hidden_size': predefined_args['embed_size'],
      'initializer_range': 0.02,
      'intermediate_size': predefined_args['hidden_size'],
      'layer_norm_eps': predefined_args['layer_norm_eps'],
      'max_position_embeddings': predefined_args['max_length'],
      'model_type': 'bort',
      'num_attention_heads': predefined_args['num_heads'],
      'num_hidden_layers': predefined_args['num_layers'],
      'pad_token_id': 1,  # 2 = BERT, 1 = RoBERTa
      'type_vocab_size': 1,  # 2 = BERT, 1 = RoBERTa
      'vocab_size': len(UpperCAmelCase__  ),
  }

  UpperCamelCase_: Dict   				=    BertConfig.from_dict(UpperCAmelCase__  )
  UpperCamelCase_: Union[str, Any]   				=    BertForMaskedLM(UpperCAmelCase__  )
  hf_bort_model.eval()

  # Parameter mapping table (Gluonnlp to Transformers)
  # * denotes layer index
  #
  # | Gluon Parameter                                                | Transformers Parameter
  # | -------------------------------------------------------------- | ----------------------
  # | `encoder.layer_norm.beta`                                      | `bert.embeddings.LayerNorm.bias`
  # | `encoder.layer_norm.gamma`                                     | `bert.embeddings.LayerNorm.weight`
  # | `encoder.position_weight`                                      | `bert.embeddings.position_embeddings.weight`
  # | `word_embed.0.weight`                                          | `bert.embeddings.word_embeddings.weight`
  # | `encoder.transformer_cells.*.attention_cell.proj_key.bias`     | `bert.encoder.layer.*.attention.self.key.bias`
  # | `encoder.transformer_cells.*.attention_cell.proj_key.weight`   | `bert.encoder.layer.*.attention.self.key.weight`
  # | `encoder.transformer_cells.*.attention_cell.proj_query.bias`   | `bert.encoder.layer.*.attention.self.query.bias`
  # | `encoder.transformer_cells.*.attention_cell.proj_query.weight` | `bert.encoder.layer.*.attention.self.query.weight`
  # | `encoder.transformer_cells.*.attention_cell.proj_value.bias`   | `bert.encoder.layer.*.attention.self.value.bias`
  # | `encoder.transformer_cells.*.attention_cell.proj_value.weight` | `bert.encoder.layer.*.attention.self.value.weight`
  # | `encoder.transformer_cells.*.ffn.ffn_2.bias`                   | `bert.encoder.layer.*.attention.output.dense.bias`
  # | `encoder.transformer_cells.*.ffn.ffn_2.weight`                 | `bert.encoder.layer.*.attention.output.dense.weight`
  # | `encoder.transformer_cells.*.layer_norm.beta`                  | `bert.encoder.layer.*.attention.output.LayerNorm.bias`
  # | `encoder.transformer_cells.*.layer_norm.gamma`                 | `bert.encoder.layer.*.attention.output.LayerNorm.weight`
  # | `encoder.transformer_cells.*.ffn.ffn_1.bias`                   | `bert.encoder.layer.*.intermediate.dense.bias`
  # | `encoder.transformer_cells.*.ffn.ffn_1.weight`                 | `bert.encoder.layer.*.intermediate.dense.weight`
  # | `encoder.transformer_cells.*.ffn.layer_norm.beta`              | `bert.encoder.layer.*.output.LayerNorm.bias`
  # | `encoder.transformer_cells.*.ffn.layer_norm.gamma`             | `bert.encoder.layer.*.output.LayerNorm.weight`
  # | `encoder.transformer_cells.*.proj.bias`                        | `bert.encoder.layer.*.output.dense.bias`
  # | `encoder.transformer_cells.*.proj.weight`                      | `bert.encoder.layer.*.output.dense.weight`

  # Helper function to convert MXNET Arrays to PyTorch
  def to_torch(UpperCAmelCase__  ) -> nn.Parameter:
    return nn.Parameter(torch.FloatTensor(mx_array.data().asnumpy()  )  )

  # Check param shapes and map new HF param back
  def check_and_map_params(UpperCAmelCase__     ,   UpperCAmelCase__  ):
    UpperCamelCase_: int   				=    hf_param.shape

    UpperCamelCase_: Tuple   				=    to_torch(params[gluon_param]  )
    UpperCamelCase_: int   				=    gluon_param.shape

    assert (
        shape_hf == shape_gluon
    ), F'''The gluon parameter {gluon_param} has shape {shape_gluon}, but expects shape {shape_hf} for Transformers'''

    return gluon_param

  UpperCamelCase_: Dict   				=    check_and_map_params(
      hf_bort_model.bert.embeddings.word_embeddings.weight     ,   'word_embed.0.weight'  )
  UpperCamelCase_: str   				=    check_and_map_params(
      hf_bort_model.bert.embeddings.position_embeddings.weight     ,   'encoder.position_weight'  )
  UpperCamelCase_: Optional[Any]   				=    check_and_map_params(
      hf_bort_model.bert.embeddings.LayerNorm.bias     ,   'encoder.layer_norm.beta'  )
  UpperCamelCase_: Union[str, Any]   				=    check_and_map_params(
      hf_bort_model.bert.embeddings.LayerNorm.weight     ,   'encoder.layer_norm.gamma'  )

  # Inspired by RoBERTa conversion script, we just zero them out (Bort does not use them)
  UpperCamelCase_: Union[str, Any]   				=    torch.zeros_like(
      hf_bort_model.bert.embeddings.token_type_embeddings.weight.data  )

  for i in range(hf_bort_config.num_hidden_layers  ):
    UpperCamelCase_: BertLayer   				=    hf_bort_model.bert.encoder.layer[i]

    # self attention
    UpperCamelCase_: BertSelfAttention   				=    layer.attention.self

    UpperCamelCase_: int   				=    check_and_map_params(
        self_attn.key.bias.data     ,   F'''encoder.transformer_cells.{i}.attention_cell.proj_key.bias'''  )

    UpperCamelCase_: Any   				=    check_and_map_params(
        self_attn.key.weight.data     ,   F'''encoder.transformer_cells.{i}.attention_cell.proj_key.weight'''  )
    UpperCamelCase_: Any   				=    check_and_map_params(
        self_attn.query.bias.data     ,   F'''encoder.transformer_cells.{i}.attention_cell.proj_query.bias'''  )
    UpperCamelCase_: Optional[int]   				=    check_and_map_params(
        self_attn.query.weight.data     ,   F'''encoder.transformer_cells.{i}.attention_cell.proj_query.weight'''  )
    UpperCamelCase_: Optional[Any]   				=    check_and_map_params(
        self_attn.value.bias.data     ,   F'''encoder.transformer_cells.{i}.attention_cell.proj_value.bias'''  )
    UpperCamelCase_: int   				=    check_and_map_params(
        self_attn.value.weight.data     ,   F'''encoder.transformer_cells.{i}.attention_cell.proj_value.weight'''  )

    # self attention output
    UpperCamelCase_: BertSelfOutput   				=    layer.attention.output

    UpperCamelCase_: str   				=    check_and_map_params(
        self_output.dense.bias     ,   F'''encoder.transformer_cells.{i}.proj.bias'''  )
    UpperCamelCase_: Dict   				=    check_and_map_params(
        self_output.dense.weight     ,   F'''encoder.transformer_cells.{i}.proj.weight'''  )
    UpperCamelCase_: List[Any]   				=    check_and_map_params(
        self_output.LayerNorm.bias     ,   F'''encoder.transformer_cells.{i}.layer_norm.beta'''  )
    UpperCamelCase_: Union[str, Any]   				=    check_and_map_params(
        self_output.LayerNorm.weight     ,   F'''encoder.transformer_cells.{i}.layer_norm.gamma'''  )

    # intermediate
    UpperCamelCase_: BertIntermediate   				=    layer.intermediate

    UpperCamelCase_: Optional[int]   				=    check_and_map_params(
        intermediate.dense.bias     ,   F'''encoder.transformer_cells.{i}.ffn.ffn_1.bias'''  )
    UpperCamelCase_: Dict   				=    check_and_map_params(
        intermediate.dense.weight     ,   F'''encoder.transformer_cells.{i}.ffn.ffn_1.weight'''  )

    # output
    UpperCamelCase_: BertOutput   				=    layer.output

    UpperCamelCase_: List[str]   				=    check_and_map_params(
        bert_output.dense.bias     ,   F'''encoder.transformer_cells.{i}.ffn.ffn_2.bias'''  )
    UpperCamelCase_: Optional[int]   				=    check_and_map_params(
        bert_output.dense.weight     ,   F'''encoder.transformer_cells.{i}.ffn.ffn_2.weight'''  )
    UpperCamelCase_: Dict   				=    check_and_map_params(
        bert_output.LayerNorm.bias     ,   F'''encoder.transformer_cells.{i}.ffn.layer_norm.beta'''  )
    UpperCamelCase_: Tuple   				=    check_and_map_params(
        bert_output.LayerNorm.weight     ,   F'''encoder.transformer_cells.{i}.ffn.layer_norm.gamma'''  )

  # Save space and energy 🎄
  hf_bort_model.half()

  # Compare output of both models
  UpperCamelCase_: List[Any]   				=    RobertaTokenizer.from_pretrained('roberta-base'  )

  UpperCamelCase_: List[Any]   				=    tokenizer.encode_plus(UpperCAmelCase__  )['input_ids']

  # Get gluon output
  UpperCamelCase_: Optional[Any]   				=    mx.nd.array([input_ids]  )
  UpperCamelCase_: List[str]   				=    original_bort(inputs=UpperCAmelCase__     ,   token_types=[]  )

  # Get Transformer output (save and reload model again)
  hf_bort_model.save_pretrained(UpperCAmelCase__  )
  UpperCamelCase_: List[Any]   				=    BertModel.from_pretrained(UpperCAmelCase__  )
  hf_bort_model.eval()

  UpperCamelCase_: List[str]   				=    tokenizer.encode_plus(UpperCAmelCase__     ,   return_tensors='pt'  )
  UpperCamelCase_: Optional[int]   				=    hf_bort_model(**UpperCAmelCase__  )[0]

  UpperCamelCase_: int   				=    output_gluon[0].asnumpy()
  UpperCamelCase_: Optional[int]   				=    output_hf[0].detach().numpy()

  UpperCamelCase_: Dict   				=    np.max(np.abs(hf_layer - gluon_layer  )  ).item()
  UpperCamelCase_: Dict   				=    np.allclose(UpperCAmelCase__     ,   UpperCAmelCase__     ,   atol=1E-3  )

  if success:
    print('✔️ Both model do output the same tensors'  )
  else:
    print('❌ Both model do **NOT** output the same tensors'  )
    print('Absolute difference is:'     ,   UpperCAmelCase__  )


if __name__ == "__main__":
   A_		:		str		     =			argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--bort_checkpoint_path', default=None, type=str, required=True, help='Path the official Bort params file.'
   )
   parser.add_argument(
       '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
   )
   A_		:		List[Any]		     =			parser.parse_args()
   convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)







import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class     _lowerCAmelCase(	UpperCAmelCase_							,     unittest.TestCase ):





       """simple docstring"""







       a    :		Optional[Any]									=CLIPTokenizer
       a    :		List[Any]									=CLIPTokenizerFast
       a    :		str									=True
       a    :		List[Any]									={}
       a    :		str									=False





       def       _a   ( self							):
         super().setUp()

         # fmt: off
         UpperCamelCase_: str   				=    ['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'l</w>', 'w</w>', 'r</w>', 't</w>', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|startoftext|>', '<|endoftext|>']
         # fmt: on
         UpperCamelCase_: Any   				=    dict(zip(_lowerCamelCase  ,      range(len(_lowerCamelCase							)							)							)							)
         UpperCamelCase_: Optional[int]   				=    ['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>']
         UpperCamelCase_: Any   				=    {'unk_token': '<unk>'}

         UpperCamelCase_: List[Any]   				=    os.path.join(self.tmpdirname  ,      VOCAB_FILES_NAMES['vocab_file']							)
         UpperCamelCase_: Optional[int]   				=    os.path.join(self.tmpdirname  ,      VOCAB_FILES_NAMES['merges_file']							)
         with open(self.vocab_file  ,      'w'  ,      encoding='utf-8'							) as fp:
           fp.write(json.dumps(_lowerCamelCase							) + '\n'							)
         with open(self.merges_file  ,      'w'  ,      encoding='utf-8'							) as fp:
           fp.write('\n'.join(_lowerCamelCase							)							)





       def       _a   ( self  ,      **_lowerCamelCase							):
         kwargs.update(self.special_tokens_map							)
         return CLIPTokenizer.from_pretrained(self.tmpdirname  ,      **_lowerCamelCase							)





       def       _a   ( self  ,      **_lowerCamelCase							):
         kwargs.update(self.special_tokens_map							)
         return CLIPTokenizerFast.from_pretrained(self.tmpdirname  ,      **_lowerCamelCase							)





       def       _a   ( self  ,      _lowerCamelCase							):
         UpperCamelCase_: Union[str, Any]   				=    'lower newer'
         UpperCamelCase_: Tuple   				=    'lower newer'
         return input_text, output_text





       def       _a   ( self							):
         UpperCamelCase_: Dict   				=    CLIPTokenizer(self.vocab_file  ,      self.merges_file  ,      **self.special_tokens_map							)
         UpperCamelCase_: Optional[int]   				=    'lower newer'
         UpperCamelCase_: Any   				=    ['lo', 'w', 'er</w>', 'n', 'e', 'w', 'er</w>']
         UpperCamelCase_: Union[str, Any]   				=    tokenizer.tokenize(_lowerCamelCase							)
         self.assertListEqual(_lowerCamelCase  ,      _lowerCamelCase							)

         UpperCamelCase_: str   				=    tokens + [tokenizer.unk_token]
         UpperCamelCase_: Optional[Any]   				=    [1_0, 2, 1_6, 9, 3, 2, 1_6, 2_0]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCamelCase							)  ,      _lowerCamelCase							)





       @require_ftfy
       def       _a   ( self							):
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''							):
             UpperCamelCase_: Optional[int]   				=    self.tokenizer_class.from_pretrained(_lowerCamelCase  ,      **_lowerCamelCase							)
             UpperCamelCase_: List[str]   				=    self.rust_tokenizer_class.from_pretrained(_lowerCamelCase  ,      **_lowerCamelCase							)

             UpperCamelCase_: Optional[int]   				=    'A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'
             UpperCamelCase_: Tuple   				=    tokenizer_s.tokenize(_lowerCamelCase							)
             UpperCamelCase_: Any   				=    tokenizer_r.tokenize(_lowerCamelCase							)

             self.assertListEqual(_lowerCamelCase  ,      _lowerCamelCase							)

             # Test that the tokenization is identical on an example containing a character (Latin Small Letter A
             # with Tilde) encoded in 2 different ways
             UpperCamelCase_: List[str]   				=    'xa\u0303y' + ' ' + 'x\xe3y'
             UpperCamelCase_: List[Any]   				=    tokenizer_s.tokenize(_lowerCamelCase							)
             UpperCamelCase_: int   				=    tokenizer_r.tokenize(_lowerCamelCase							)

             self.assertListEqual(_lowerCamelCase  ,      _lowerCamelCase							)

             # Test that the tokenization is identical on unicode of space type
             UpperCamelCase_: Dict   				=    [
                 '\u0009',  # (horizontal tab, '\t')
                 '\u000B',  # (vertical tab)
                 '\u000C',  # (form feed)
                 '\u0020',  # (space, ' ')
                 '\u200E',  # (left-to-right mark):w
                 '\u200F',  # (right-to-left mark)
             ]
             for unicode_seq in spaces_unicodes:
               UpperCamelCase_: int   				=    tokenizer_s.tokenize(_lowerCamelCase							)
               UpperCamelCase_: Dict   				=    tokenizer_r.tokenize(_lowerCamelCase							)

               self.assertListEqual(_lowerCamelCase  ,      _lowerCamelCase							)

             # Test that the tokenization is identical on unicode of line break type
             UpperCamelCase_: List[str]   				=    [
                 '\u000A',  # (line feed, '\n')
                 '\r\n',  # (carriage return and line feed, '\r\n')
                 '\u000D',  # (carriage return, '\r')
                 '\r',  # (carriage return, '\r')
                 '\u000D',  # (carriage return, '\r')
                 '\u2028',  # (line separator)
                 '\u2029',  # (paragraph separator)
                 # "\u0085", # (next line)
             ]

             # The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
             # it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
             # space (and thus into an empty list).

             for unicode_seq in line_break_unicodes:
               UpperCamelCase_: Optional[Any]   				=    tokenizer_s.tokenize(_lowerCamelCase							)
               UpperCamelCase_: str   				=    tokenizer_r.tokenize(_lowerCamelCase							)

               self.assertListEqual(_lowerCamelCase  ,      _lowerCamelCase							)





       def       _a   ( self							):
         # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''							):
             UpperCamelCase_: str   				=    'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
             UpperCamelCase_: str   				=    f'''{text_of_1_token} {text_of_1_token}'''

             UpperCamelCase_: Optional[Any]   				=    self.rust_tokenizer_class.from_pretrained(
                 _lowerCamelCase  ,      use_fast=_lowerCamelCase  ,      )
             UpperCamelCase_: int   				=    tokenizer_r(_lowerCamelCase  ,      return_offsets_mapping=_lowerCamelCase  ,      add_special_tokens=_lowerCamelCase							)
             self.assertEqual(encoding.offset_mapping[0]  ,      (0, len(_lowerCamelCase							))							)
             self.assertEqual(
                 encoding.offset_mapping[1]  ,      (len(_lowerCamelCase							) + 1, len(_lowerCamelCase							) + 1 + len(_lowerCamelCase							))  ,      )

             UpperCamelCase_: List[str]   				=    f''' {text}'''

             UpperCamelCase_: str   				=    self.rust_tokenizer_class.from_pretrained(
                 _lowerCamelCase  ,      use_fast=_lowerCamelCase  ,      )
             UpperCamelCase_: Dict   				=    tokenizer_r(_lowerCamelCase  ,      return_offsets_mapping=_lowerCamelCase  ,      add_special_tokens=_lowerCamelCase							)
             self.assertEqual(encoding.offset_mapping[0]  ,      (1, 1 + len(_lowerCamelCase							))							)
             self.assertEqual(
                 encoding.offset_mapping[1]  ,      (1 + len(_lowerCamelCase							) + 1, 1 + len(_lowerCamelCase							) + 1 + len(_lowerCamelCase							))  ,      )





       def       _a   ( self							):
         # Test related to the breaking change introduced in transformers v4.17.0
         # We need to check that an error in raised when the user try to load a previous version of the tokenizer.
         with self.assertRaises(_lowerCamelCase							) as context:
           self.rust_tokenizer_class.from_pretrained('robot-test/old-clip-tokenizer'							)

         self.assertTrue(
             context.exception.args[0].startswith(
                 'The `backend_tokenizer` provided does not match the expected format.'							)							)





       @require_ftfy
       def       _a   ( self							):
         super().test_tokenization_python_rust_equals()





       def       _a   ( self							):
         # CLIP always lower cases letters
         pass