
import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConfig,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaForCTC,
    WavaVecaForPreTraining,
    WavaVecaProcessor,
    logging,
)
from transformers.models.wavaveca.modeling_wavaveca import WavaVecaForSequenceClassification


logging.set_verbosity_info()
lowercase  :					Union[str, Any]						    =							logging.get_logger(__name__)

lowercase  :					Any						    =							{
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
    "fc2": "encoder.layers.*.feed_forward.output_dense",
    "final_layer_norm": "encoder.layers.*.final_layer_norm",
    "encoder.layer_norm": "encoder.layer_norm",
    "adapter_layer": "encoder.layers.*.adapter_layer",
    "w2v_model.layer_norm": "feature_projection.layer_norm",
    "quantizer.weight_proj": "quantizer.weight_proj",
    "quantizer.vars": "quantizer.codevectors",
    "project_q": "project_q",
    "final_proj": "project_hid",
    "w2v_encoder.proj": "lm_head",
    "mask_emb": "masked_spec_embed",
    "pooling_layer.linear": "projector",
    "pooling_layer.projection": "classifier",
}
lowercase  :					Dict						    =							[
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
    "projector",
    "classifier",
]







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    List[str]:
       lowercase							:     Optional[Any]       	=      {}
       with open(__lowerCamelCase					,	"""r"""				) as file:
              for line_number, line in enumerate(__lowerCamelCase				):
                     lowercase							:     Tuple       	=      line.strip()
                     if line:
                            lowercase							:     Union[str, Any]       	=      line.split()
                            lowercase							:     Dict       	=      line_number
                            lowercase							:     Union[str, Any]       	=      words[0]
                            lowercase							:     List[Any]       	=      value
       return result







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) ->    Dict:
       for attribute in key.split("""."""				):
              lowercase							:     Union[str, Any]       	=      getattr(__lowerCamelCase					,	__lowerCamelCase				)

       lowercase							:     str       	=      None
       for param_key in PARAM_MAPPING.keys():
              if full_name.endswith(__lowerCamelCase				):
                     lowercase							:     str       	=      PARAM_MAPPING[full_name.split("""."""				)[-1]]
                     lowercase							:     str       	=      """param"""

       if weight_type is not None and weight_type != "param":
              lowercase							:     Any       	=      getattr(__lowerCamelCase					,	__lowerCamelCase				).shape
       elif weight_type is not None and weight_type == "param":
              lowercase							:     int       	=      hf_pointer
              for attribute in hf_param_name.split("""."""				):
                     lowercase							:     str       	=      getattr(__lowerCamelCase					,	__lowerCamelCase				)
              lowercase							:     Tuple       	=      shape_pointer.shape

              # let's reduce dimension
              lowercase							:     Optional[int]       	=      value[0]
       else:
              lowercase							:     Union[str, Any]       	=      hf_pointer.shape

       if hf_shape != value.shape:
              raise ValueError(
                  f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
                  f" {value.shape} for {full_name}"				)

       if weight_type == "weight":
              lowercase							:     Optional[int]       	=      value
       elif weight_type == "weight_g":
              lowercase							:     Tuple       	=      value
       elif weight_type == "weight_v":
              lowercase							:     List[str]       	=      value
       elif weight_type == "bias":
              lowercase							:     List[Any]       	=      value
       elif weight_type == "param":
              for attribute in hf_param_name.split("""."""				):
                     lowercase							:     Any       	=      getattr(__lowerCamelCase					,	__lowerCamelCase				)
              lowercase							:     List[str]       	=      value
       else:
              lowercase							:     int       	=      value

       logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."				)







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) ->    Union[str, Any]:
       lowercase							:     int       	=      None
       for param_key in PARAM_MAPPING.keys():
              if full_name.endswith(__lowerCamelCase				):
                     lowercase							:     List[Any]       	=      PARAM_MAPPING[full_name.split("""."""				)[-1]]
                     lowercase							:     List[str]       	=      """param"""

       if weight_type is not None and weight_type != "param":
              lowercase							:     Optional[Any]       	=      """.""".join([key, weight_type]				)
       elif weight_type is not None and weight_type == "param":
              lowercase							:     Optional[Any]       	=      """.""".join([key, hf_param_name]				)
       else:
              lowercase							:     int       	=      key

       lowercase							:     int       	=      value if """lm_head""" in full_key else value[0]


lowercase  :					List[Any]						    =							{
    "W_a": "linear_1.weight",
    "W_b": "linear_2.weight",
    "b_a": "linear_1.bias",
    "b_b": "linear_2.bias",
    "ln_W": "norm.weight",
    "ln_b": "norm.bias",
}







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__=None					,	SCREAMING_SNAKE_CASE__=None				) ->    Optional[Any]:
       lowercase							:     Any       	=      False
       for key, mapped_key in MAPPING.items():
              lowercase							:     str       	=      """wav2vec2.""" + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
              if key in name or key.split("""w2v_model."""				)[-1] == name.split("""."""				)[0]:
                     lowercase							:     List[Any]       	=      True
                     if "*" in mapped_key:
                            lowercase							:     str       	=      name.split(__lowerCamelCase				)[0].split("""."""				)[-2]
                            lowercase							:     Any       	=      mapped_key.replace("""*"""					,	__lowerCamelCase				)
                     if "weight_g" in name:
                            lowercase							:     str       	=      """weight_g"""
                     elif "weight_v" in name:
                            lowercase							:     List[Any]       	=      """weight_v"""
                     elif "bias" in name:
                            lowercase							:     str       	=      """bias"""
                     elif "weight" in name:
                            # TODO: don't match quantizer.weight_proj
                            lowercase							:     Tuple       	=      """weight"""
                     else:
                            lowercase							:     Union[str, Any]       	=      None
                     if hf_dict is not None:
                            rename_dict(__lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase				)
                     else:
                            set_recursively(__lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase				)
                     return is_used
       return is_used







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) ->    List[Any]:
       lowercase							:     Any       	=      []
       lowercase							:     int       	=      fairseq_model.state_dict()

       lowercase							:     int       	=      hf_model.wavaveca.feature_extractor

       for name, value in fairseq_dict.items():
              lowercase							:     Any       	=      False
              if "conv_layers" in name:
                     load_conv_layer(
                         __lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase					,	hf_model.config.feat_extract_norm == """group"""					,	)
                     lowercase							:     Tuple       	=      True
              else:
                     lowercase							:     List[Any]       	=      load_wavaveca_layer(__lowerCamelCase					,	__lowerCamelCase					,	__lowerCamelCase				)
              if not is_used:
                     unused_weights.append(__lowerCamelCase				)

       logger.warning(f"Unused weights: {unused_weights}"				)







def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) ->    Any:
       lowercase							:     Dict       	=      full_name.split("""conv_layers."""				)[-1]
       lowercase							:     int       	=      name.split("""."""				)
       lowercase							:     Optional[int]       	=      int(items[0]				)
       lowercase							:     Dict       	=      int(items[1]				)

       if type_id == 0:
              if "bias" in name:
                     if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
                            raise ValueError(
                                f"{full_name} has size {value.shape}, but"
                                f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."				)
                     lowercase							:     List[Any]       	=      value
                     logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."				)
              elif "weight" in name:
                     if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
                            raise ValueError(
                                f"{full_name} has size {value.shape}, but"
                                f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."				)
                     lowercase							:     List[Any]       	=      value
                     logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."				)
       elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
              if "bias" in name:
                     if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
                            raise ValueError(
                                f"{full_name} has size {value.shape}, but"
                                f" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found."				)
                     lowercase							:     List[Any]       	=      value
                     logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."				)
              elif "weight" in name:
                     if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
                            raise ValueError(
                                f"{full_name} has size {value.shape}, but"
                                f" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found."				)
                     lowercase							:     List[Any]       	=      value
                     logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."				)
       else:
              unused_weights.append(__lowerCamelCase				)







@torch.no_grad()
def 						_snake_case(  SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__=None					,	SCREAMING_SNAKE_CASE__=None					,	SCREAMING_SNAKE_CASE__=True					,	SCREAMING_SNAKE_CASE__=False				) ->    List[Any]:
       if config_path is not None:
              lowercase							:     int       	=      WavaVecaConfig.from_pretrained(__lowerCamelCase				)
       else:
              lowercase							:     Union[str, Any]       	=      WavaVecaConfig()

       if is_seq_class:
              lowercase							:     Union[str, Any]       	=      read_txt_into_dict(__lowerCamelCase				)
              lowercase							:     List[Any]       	=      idalabel
              lowercase							:     Optional[int]       	=      WavaVecaForSequenceClassification(__lowerCamelCase				)
              lowercase							:     Optional[int]       	=      WavaVecaFeatureExtractor(
                  feature_size=1					,	sampling_rate=16_000					,	padding_value=0					,	do_normalize=__lowerCamelCase					,	return_attention_mask=__lowerCamelCase					,	)
              feature_extractor.save_pretrained(__lowerCamelCase				)

       elif is_finetuned:
              if dict_path:
                     lowercase							:     List[str]       	=      Dictionary.load(__lowerCamelCase				)

                     # important change bos & pad token id since CTC symbol is <pad> and
                     # not <s> as in fairseq
                     lowercase							:     Optional[Any]       	=      target_dict.pad_index
                     lowercase							:     str       	=      target_dict.bos_index
                     lowercase							:     Union[str, Any]       	=      target_dict.eos_index
                     lowercase							:     int       	=      len(target_dict.symbols				)
                     lowercase							:     List[Any]       	=      os.path.join(__lowerCamelCase					,	"""vocab.json"""				)
                     if not os.path.isdir(__lowerCamelCase				):
                            logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(__lowerCamelCase				)				)
                            return
                     os.makedirs(__lowerCamelCase					,	exist_ok=__lowerCamelCase				)
                     lowercase							:     Union[str, Any]       	=      target_dict.indices

                     # fairseq has the <pad> and <s> switched
                     lowercase							:     Any       	=      0
                     lowercase							:     Dict       	=      1
                     with open(__lowerCamelCase					,	"""w"""					,	encoding="""utf-8"""				) as vocab_handle:
                            json.dump(__lowerCamelCase					,	__lowerCamelCase				)
                     lowercase							:     Any       	=      WavaVecaCTCTokenizer(
                         __lowerCamelCase					,	unk_token=target_dict.unk_word					,	pad_token=target_dict.pad_word					,	bos_token=target_dict.bos_word					,	eos_token=target_dict.eos_word					,	word_delimiter_token="""|"""					,	do_lower_case=__lowerCamelCase					,	)
                     lowercase							:     Dict       	=      True if config.feat_extract_norm == """layer""" else False
                     lowercase							:     List[Any]       	=      WavaVecaFeatureExtractor(
                         feature_size=1					,	sampling_rate=16_000					,	padding_value=0					,	do_normalize=__lowerCamelCase					,	return_attention_mask=__lowerCamelCase					,	)
                     lowercase							:     List[str]       	=      WavaVecaProcessor(feature_extractor=__lowerCamelCase					,	tokenizer=__lowerCamelCase				)
                     processor.save_pretrained(__lowerCamelCase				)

              lowercase							:     Optional[int]       	=      WavaVecaForCTC(__lowerCamelCase				)
       else:
              lowercase							:     Any       	=      WavaVecaForPreTraining(__lowerCamelCase				)

       if is_finetuned or is_seq_class:
              lowercase	,			lowercase	,			lowercase							:     Union[str, Any]       	=      fairseq.checkpoint_utils.load_model_ensemble_and_task(
                  [checkpoint_path]					,	arg_overrides={"""data""": """/""".join(dict_path.split("""/"""				)[:-1]				)}				)
       else:
              lowercase							:     int       	=      argparse.Namespace(task="""audio_pretraining"""				)
              lowercase							:     Optional[Any]       	=      fairseq.tasks.setup_task(__lowerCamelCase				)

              lowercase	,			lowercase	,			lowercase							:     str       	=      fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]					,	task=__lowerCamelCase				)

       lowercase							:     Union[str, Any]       	=      model[0].eval()

       recursively_load_weights(__lowerCamelCase					,	__lowerCamelCase					,	not is_finetuned				)

       hf_wavavec.save_pretrained(__lowerCamelCase				)


if __name__ == "__main__":
  lowercase  :					int						    =							argparse.ArgumentParser()
  parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
  parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
  parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
  parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
  parser.add_argument(
      """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not"""
  )
  parser.add_argument(
      """--is_seq_class""",
      action="""store_true""",
      help="""Whether the model to convert is a fine-tuned sequence classification model or not""",
  )
  lowercase  :					Union[str, Any]						    =							parser.parse_args()

  lowercase  :					Any						    =							not args.not_finetuned and not args.is_seq_class
  convert_wavaveca_checkpoint(
      args.checkpoint_path,
      args.pytorch_dump_folder_path,
      args.config_path,
      args.dict_path,
      is_finetuned,
      args.is_seq_class,
  )






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	(	__magic_name__      ,       unittest.TestCase ):
							UpperCamelCase__					     =  CLIPTokenizer
							UpperCamelCase__					     =  CLIPTokenizerFast
							UpperCamelCase__					     =  True
							UpperCamelCase__					     =  {}
							UpperCamelCase__					     =  False
							def       lowerCamelCase__							(						self						:str				):







								'''simple docstring'''







								super().setUp()

								# fmt: off
								a										=							["""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
								a										=							dict(zip(__magic_name__		,      range(len(__magic_name__				)				)				)				)
								a										=							["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>"""]
								a										=							{"""unk_token""": """<unk>"""}

								a										=							os.path.join(self.tmpdirname		,      VOCAB_FILES_NAMES["""vocab_file"""]				)
								a										=							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(__magic_name__				) + """\n"""				)
								with open(self.merges_file		,      """w"""		,      encoding="""utf-8"""				) as fp:
									fp.write("""\n""".join(__magic_name__				)				)
							def       lowerCamelCase__							(						self						:Optional[Any]		,      **__magic_name__						:Union[str, Any]				):







								'''simple docstring'''







								kwargs.update(self.special_tokens_map				)
								return CLIPTokenizer.from_pretrained(self.tmpdirname		,      **__magic_name__				)
							def       lowerCamelCase__							(						self						:int		,      **__magic_name__						:Optional[Any]				):







								'''simple docstring'''







								kwargs.update(self.special_tokens_map				)
								return CLIPTokenizerFast.from_pretrained(self.tmpdirname		,      **__magic_name__				)
							def       lowerCamelCase__							(						self						:int		,      __magic_name__						:List[str]				):







								'''simple docstring'''







								a										=							"""lower newer"""
								a										=							"""lower newer"""
								return input_text, output_text
							def       lowerCamelCase__							(						self						:int				):







								'''simple docstring'''







								a										=							CLIPTokenizer(self.vocab_file		,      self.merges_file		,      **self.special_tokens_map				)
								a										=							"""lower newer"""
								a										=							["""lo""", """w""", """er</w>""", """n""", """e""", """w""", """er</w>"""]
								a										=							tokenizer.tokenize(__magic_name__				)
								self.assertListEqual(__magic_name__		,      __magic_name__				)

								a										=							tokens + [tokenizer.unk_token]
								a										=							[10, 2, 16, 9, 3, 2, 16, 20]
								self.assertListEqual(tokenizer.convert_tokens_to_ids(__magic_name__				)		,      __magic_name__				)
							@require_ftfy
							def       lowerCamelCase__							(						self						:List[Any]				):







								'''simple docstring'''







								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'				):
										a										=							self.tokenizer_class.from_pretrained(__magic_name__		,      **__magic_name__				)
										a										=							self.rust_tokenizer_class.from_pretrained(__magic_name__		,      **__magic_name__				)

										a										=							"""A\n'll 11p223RF☆ho!!to?'d'd''d of a cat to-$''d."""
										a										=							tokenizer_s.tokenize(__magic_name__				)
										a										=							tokenizer_r.tokenize(__magic_name__				)

										self.assertListEqual(__magic_name__		,      __magic_name__				)

										# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
										# with Tilde) encoded in 2 different ways
										a										=							"""xa\u0303y""" + """ """ + """x\xe3y"""
										a										=							tokenizer_s.tokenize(__magic_name__				)
										a										=							tokenizer_r.tokenize(__magic_name__				)

										self.assertListEqual(__magic_name__		,      __magic_name__				)

										# Test that the tokenization is identical on unicode of space type
										a										=							[
										    """\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:
											a										=							tokenizer_s.tokenize(__magic_name__				)
											a										=							tokenizer_r.tokenize(__magic_name__				)

											self.assertListEqual(__magic_name__		,      __magic_name__				)

										# Test that the tokenization is identical on unicode of line break type
										a										=							[
										    """\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:
											a										=							tokenizer_s.tokenize(__magic_name__				)
											a										=							tokenizer_r.tokenize(__magic_name__				)

											self.assertListEqual(__magic_name__		,      __magic_name__				)
							def       lowerCamelCase__							(						self						:int				):







								'''simple docstring'''







								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'				):
										a										=							"""hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
										a										=							F'{text_of_1_token} {text_of_1_token}'

										a										=							self.rust_tokenizer_class.from_pretrained(
										    __magic_name__		,      use_fast=__magic_name__		,      )
										a										=							tokenizer_r(__magic_name__		,      return_offsets_mapping=__magic_name__		,      add_special_tokens=__magic_name__				)
										self.assertEqual(encoding.offset_mapping[0]		,      (0, len(__magic_name__				))				)
										self.assertEqual(
										    encoding.offset_mapping[1]		,      (len(__magic_name__				) + 1, len(__magic_name__				) + 1 + len(__magic_name__				))		,      )

										a										=							F' {text}'

										a										=							self.rust_tokenizer_class.from_pretrained(
										    __magic_name__		,      use_fast=__magic_name__		,      )
										a										=							tokenizer_r(__magic_name__		,      return_offsets_mapping=__magic_name__		,      add_special_tokens=__magic_name__				)
										self.assertEqual(encoding.offset_mapping[0]		,      (1, 1 + len(__magic_name__				))				)
										self.assertEqual(
										    encoding.offset_mapping[1]		,      (1 + len(__magic_name__				) + 1, 1 + len(__magic_name__				) + 1 + len(__magic_name__				))		,      )
							def       lowerCamelCase__							(						self						:List[str]				):







								'''simple docstring'''







								with self.assertRaises(__magic_name__				) 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       lowerCamelCase__							(						self						:Tuple				):







								'''simple docstring'''







								super().test_tokenization_python_rust_equals()





							def       lowerCamelCase__							(						self						:Optional[int]				):







								'''simple docstring'''







								pass

