


'''simple docstring'''


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()
_UpperCamelCase 							=  logging.get_logger(__name__)

_UpperCamelCase 							=  {
    """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""",
}
_UpperCamelCase 							=  [
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
    """projector""",
    """classifier""",
]


def 		_lowercase (SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     __A	:       Dict      =							{}
     with open(SCREAMING_SNAKE_CASE       ,					"r"							) as file:
          for line_number, line in enumerate(SCREAMING_SNAKE_CASE							):
               __A	:       str      =							line.strip()
               if line:
                    __A	:       Union[str, Any]      =							line.split()
                    __A	:       List[str]      =							line_number
                    __A	:       Optional[Any]      =							words[0]
                    __A	:       Any      =							value
     return result


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     for attribute in key.split("."							):
          __A	:       Dict      =							getattr(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)

     __A	:       Optional[Any]      =							None
     for param_key in PARAM_MAPPING.keys():
          if full_name.endswith(SCREAMING_SNAKE_CASE							):
               __A	:       List[Any]      =							PARAM_MAPPING[full_name.split("."							)[-1]]
               __A	:       List[str]      =							"param"

     if weight_type is not None and weight_type != "param":
          __A	:       Dict      =							getattr(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							).shape
     elif weight_type is not None and weight_type == "param":
          __A	:       Optional[Any]      =							hf_pointer
          for attribute in hf_param_name.split("."							):
               __A	:       int      =							getattr(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)
          __A	:       str      =							shape_pointer.shape

          # let's reduce dimension
          __A	:       List[Any]      =							value[0]
     else:
          __A	:       int      =							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":
          __A	:       Optional[int]      =							value
     elif weight_type == "weight_g":
          __A	:       Any      =							value
     elif weight_type == "weight_v":
          __A	:       Tuple      =							value
     elif weight_type == "bias":
          __A	:       Tuple      =							value
     elif weight_type == "param":
          for attribute in hf_param_name.split("."							):
               __A	:       Dict      =							getattr(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)
          __A	:       List[str]      =							value
     else:
          __A	:       List[Any]      =							value

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


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     __A	:       Optional[int]      =							None
     for param_key in PARAM_MAPPING.keys():
          if full_name.endswith(SCREAMING_SNAKE_CASE							):
               __A	:       Optional[Any]      =							PARAM_MAPPING[full_name.split("."							)[-1]]
               __A	:       str      =							"param"

     if weight_type is not None and weight_type != "param":
          __A	:       Union[str, Any]      =							".".join([key, weight_type]							)
     elif weight_type is not None and weight_type == "param":
          __A	:       List[str]      =							".".join([key, hf_param_name]							)
     else:
          __A	:       Union[str, Any]      =							key

     __A	:       Optional[Any]      =							value if "lm_head" in full_key else value[0]


_UpperCamelCase 							=  {
    """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 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE=None       ,					SCREAMING_SNAKE_CASE=None							):




     '''simple docstring'''





     __A	:       Optional[Any]      =							False
     for key, mapped_key in MAPPING.items():
          __A	:       int      =							"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]:
               __A	:       List[Any]      =							True
               if "*" in mapped_key:
                    __A	:       Any      =							name.split(SCREAMING_SNAKE_CASE							)[0].split("."							)[-2]
                    __A	:       Any      =							mapped_key.replace("*"       ,					SCREAMING_SNAKE_CASE							)
               if "weight_g" in name:
                    __A	:       Dict      =							"weight_g"
               elif "weight_v" in name:
                    __A	:       Union[str, Any]      =							"weight_v"
               elif "bias" in name:
                    __A	:       List[Any]      =							"bias"
               elif "weight" in name:
                    # TODO: don't match quantizer.weight_proj
                    __A	:       List[Any]      =							"weight"
               else:
                    __A	:       Any      =							None
               if hf_dict is not None:
                    rename_dict(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)
               else:
                    set_recursively(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)
               return is_used
     return is_used


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     __A	:       Tuple      =							[]
     __A	:       Any      =							fairseq_model.state_dict()

     __A	:       str      =							hf_model.wavaveca.feature_extractor

     for name, value in fairseq_dict.items():
          __A	:       List[str]      =							False
          if "conv_layers" in name:
               load_conv_layer(
                   SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					hf_model.config.feat_extract_norm == "group"       ,					)
               __A	:       Optional[int]      =							True
          else:
               __A	:       Union[str, Any]      =							load_wavaveca_layer(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)
          if not is_used:
               unused_weights.append(SCREAMING_SNAKE_CASE							)

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


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     __A	:       List[str]      =							full_name.split("conv_layers."							)[-1]
     __A	:       Union[str, Any]      =							name.split("."							)
     __A	:       Union[str, Any]      =							int(items[0]							)
     __A	:       Optional[int]      =							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."							)
               __A	:       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."							)
               __A	:       str      =							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."							)
               __A	:       Optional[int]      =							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."							)
               __A	:       Tuple      =							value
               logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."							)
     else:
          unused_weights.append(SCREAMING_SNAKE_CASE							)


@torch.no_grad()
def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE=None       ,					SCREAMING_SNAKE_CASE=None       ,					SCREAMING_SNAKE_CASE=True       ,					SCREAMING_SNAKE_CASE=False							):




     '''simple docstring'''





     if config_path is not None:
          __A	:       int      =							WavaVecaConfig.from_pretrained(SCREAMING_SNAKE_CASE							)
     else:
          __A	:       Any      =							WavaVecaConfig()

     if is_seq_class:
          __A	:       Tuple      =							read_txt_into_dict(SCREAMING_SNAKE_CASE							)
          __A	:       Union[str, Any]      =							idalabel
          __A	:       int      =							WavaVecaForSequenceClassification(SCREAMING_SNAKE_CASE							)
          __A	:       Optional[int]      =							WavaVecaFeatureExtractor(
              feature_size=1       ,					sampling_rate=1_6000       ,					padding_value=0       ,					do_normalize=SCREAMING_SNAKE_CASE       ,					return_attention_mask=SCREAMING_SNAKE_CASE       ,					)
          feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE							)

     elif is_finetuned:
          if dict_path:
               __A	:       Any      =							Dictionary.load(SCREAMING_SNAKE_CASE							)

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

               # fairseq has the <pad> and <s> switched
               __A	:       Union[str, Any]      =							0
               __A	:       List[str]      =							1
               with open(SCREAMING_SNAKE_CASE       ,					"w"       ,					encoding="utf-8"							) as vocab_handle:
                    json.dump(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)
               __A	:       Optional[int]      =							WavaVecaCTCTokenizer(
                   SCREAMING_SNAKE_CASE       ,					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=SCREAMING_SNAKE_CASE       ,					)
               __A	:       str      =							True if config.feat_extract_norm == "layer" else False
               __A	:       List[Any]      =							WavaVecaFeatureExtractor(
                   feature_size=1       ,					sampling_rate=1_6000       ,					padding_value=0       ,					do_normalize=SCREAMING_SNAKE_CASE       ,					return_attention_mask=SCREAMING_SNAKE_CASE       ,					)
               __A	:       int      =							WavaVecaProcessor(feature_extractor=SCREAMING_SNAKE_CASE       ,					tokenizer=SCREAMING_SNAKE_CASE							)
               processor.save_pretrained(SCREAMING_SNAKE_CASE							)

          __A	:       Tuple      =							WavaVecaForCTC(SCREAMING_SNAKE_CASE							)
     else:
          __A	:       Any      =							WavaVecaForPreTraining(SCREAMING_SNAKE_CASE							)

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

          __A  ,__A  ,__A	:       int      =							fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]       ,					task=SCREAMING_SNAKE_CASE							)

     __A	:       Optional[int]      =							model[0].eval()

     recursively_load_weights(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					not is_finetuned							)

     hf_wavavec.save_pretrained(SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
      _UpperCamelCase 							=  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""",
      )
      _UpperCamelCase 							=  parser.parse_args()

      _UpperCamelCase 							=  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,
      )





'''simple docstring'''


import unittest

from transformers import CamembertTokenizer, CamembertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


_UpperCamelCase 							=  get_tests_dir("""fixtures/test_sentencepiece.model""")
_UpperCamelCase 							=  get_tests_dir("""fixtures/test_sentencepiece_bpe.model""")

_UpperCamelCase 							=  """pt""" if is_torch_available() else """tf"""







@require_sentencepiece
@require_tokenizers
class 							__magic_name__	(       lowerCAmelCase    ,		unittest.TestCase ):

     """simple docstring"""






     lowerCamelCase__       						=				CamembertTokenizer
     lowerCamelCase__       						=				CamembertTokenizerFast
     lowerCamelCase__       						=				True
     lowerCamelCase__       						=				True


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          super().setUp()

          # We have a SentencePiece fixture for testing
          __A	:       List[Any]      =							CamembertTokenizer(lowerCamelCase		)
          tokenizer.save_pretrained(self.tmpdirname		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[Any]      =							"<pad>"
          __A	:       Union[str, Any]      =							1

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


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Union[str, Any]      =							list(self.get_tokenizer().get_vocab().keys()		)

          self.assertEqual(vocab_keys[0]			,     "<s>NOTUSED"		)
          self.assertEqual(vocab_keys[1]			,     "<pad>"		)
          self.assertEqual(vocab_keys[-1]			,     "<mask>"		)
          self.assertEqual(len(lowerCamelCase		)			,     1004		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          self.assertEqual(self.get_tokenizer().vocab_size			,     1005		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[Any]      =							CamembertTokenizer(lowerCamelCase		)
          tokenizer.save_pretrained(self.tmpdirname		)
          __A	:       Optional[int]      =							CamembertTokenizerFast.from_pretrained(self.tmpdirname		)

          __A	:       str      =							"I was born in 92000, and this is falsé."

          __A	:       List[Any]      =							tokenizer.encode(lowerCamelCase		)
          __A	:       Tuple      =							rust_tokenizer.encode(lowerCamelCase		)
          self.assertListEqual(lowerCamelCase			,     lowerCamelCase		)

          __A	:       Dict      =							tokenizer.encode(lowerCamelCase			,     add_special_tokens=lowerCamelCase		)
          __A	:       str      =							rust_tokenizer.encode(lowerCamelCase			,     add_special_tokens=lowerCamelCase		)
          self.assertListEqual(lowerCamelCase			,     lowerCamelCase		)

          # <unk> tokens are not the same for `rust` than for `slow`.
          # Because spm gives back raw token instead of `unk` in EncodeAsPieces
          # tokens = tokenizer.tokenize(sequence)
          __A	:       int      =							tokenizer.convert_ids_to_tokens(lowerCamelCase		)
          __A	:       Optional[int]      =							rust_tokenizer.tokenize(lowerCamelCase		)
          self.assertListEqual(lowerCamelCase			,     lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          if not self.test_rust_tokenizer:
               return

          __A	:       Tuple      =							self.get_tokenizer()
          __A	:       List[Any]      =							self.get_rust_tokenizer()

          __A	:       Any      =							"I was born in 92000, and this is falsé."

          __A	:       int      =							tokenizer.tokenize(lowerCamelCase		)
          __A	:       Any      =							rust_tokenizer.tokenize(lowerCamelCase		)
          self.assertListEqual(lowerCamelCase			,     lowerCamelCase		)

          __A	:       Any      =							tokenizer.encode(lowerCamelCase			,     add_special_tokens=lowerCamelCase		)
          __A	:       Optional[int]      =							rust_tokenizer.encode(lowerCamelCase			,     add_special_tokens=lowerCamelCase		)
          self.assertListEqual(lowerCamelCase			,     lowerCamelCase		)

          __A	:       Union[str, Any]      =							self.get_rust_tokenizer()
          __A	:       Optional[Any]      =							tokenizer.encode(lowerCamelCase		)
          __A	:       Dict      =							rust_tokenizer.encode(lowerCamelCase		)
          self.assertListEqual(lowerCamelCase			,     lowerCamelCase		)


     @slow
     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Any      =							{"input_ids": [[5, 54, 7196, 297, 30, 23, 776, 18, 11, 3215, 3705, 8252, 22, 3164, 1181, 2116, 29, 16, 813, 25, 791, 3314, 20, 3446, 38, 2_7575, 120, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [5, 468, 17, 11, 9088, 20, 1517, 8, 2_2804, 1_8818, 10, 38, 629, 607, 607, 142, 19, 7196, 867, 56, 1_0326, 24, 2267, 20, 416, 5072, 1_5612, 233, 734, 7, 2399, 27, 16, 3015, 1649, 7, 24, 20, 4338, 2399, 27, 13, 3400, 14, 13, 6189, 8, 930, 9, 6]], "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, 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, 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

          # camembert is a french model. So we also use french texts.
          __A	:       int      =							[
              "Le transformeur est un modèle d'apprentissage profond introduit en 2017, "
              "utilisé principalement dans le domaine du traitement automatique des langues (TAL).",
              "À l'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus "
              "pour gérer des données séquentielles, telles que le langage naturel, pour des tâches "
              "telles que la traduction et la synthèse de texte.",
          ]

          self.tokenizer_integration_test_util(
              expected_encoding=lowerCamelCase			,     model_name="camembert-base"			,     revision="3a0641d9a1aeb7e848a74299e7e4c4bca216b4cf"			,     sequences=lowerCamelCase			,     )

