






import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import YolosImageProcessor


class       __SCREAMING_SNAKE_CASE   (				unittest.TestCase):






						def __init__(		self       ,  _UpperCamelCase       ,  _UpperCamelCase=7       ,  _UpperCamelCase=3       ,  _UpperCamelCase=30       ,  _UpperCamelCase=4_00       ,  _UpperCamelCase=True       ,  _UpperCamelCase=None       ,  _UpperCamelCase=True       ,  _UpperCamelCase=[0.5, 0.5, 0.5]       ,  _UpperCamelCase=[0.5, 0.5, 0.5]       ,  _UpperCamelCase=True       ,  _UpperCamelCase=1 / 2_55       ,  _UpperCamelCase=True       ,  ):






												"""simple docstring"""
												lowerCAmelCase__        =  size if size is not None else {'shortest_edge': 18, 'longest_edge': 13_33}
												lowerCAmelCase__        =  parent
												lowerCAmelCase__        =  batch_size
												lowerCAmelCase__        =  num_channels
												lowerCAmelCase__        =  min_resolution
												lowerCAmelCase__        =  max_resolution
												lowerCAmelCase__        =  do_resize
												lowerCAmelCase__        =  size
												lowerCAmelCase__        =  do_normalize
												lowerCAmelCase__        =  image_mean
												lowerCAmelCase__        =  image_std
												lowerCAmelCase__        =  do_rescale
												lowerCAmelCase__        =  rescale_factor
												lowerCAmelCase__        =  do_pad






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return {
												    "do_resize": self.do_resize,
												    "size": self.size,
												    "do_normalize": self.do_normalize,
												    "image_mean": self.image_mean,
												    "image_std": self.image_std,
												    "do_rescale": self.do_rescale,
												    "rescale_factor": self.rescale_factor,
												    "do_pad": self.do_pad,
												}







						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase=False				):






												"""simple docstring"""
												if not batched:
																		lowerCAmelCase__        =  image_inputs[0]
																		if isinstance(_UpperCamelCase       ,  Image.Image				):
																								lowerCAmelCase__  ,    lowerCAmelCase__        =  image.size
																		else:
																								lowerCAmelCase__  ,    lowerCAmelCase__        =  image.shape[1], image.shape[2]
																		if w < h:
																								lowerCAmelCase__        =  int(self.size['shortest_edge'] * h / w				)
																								lowerCAmelCase__        =  self.size['shortest_edge']
																		elif w > h:
																								lowerCAmelCase__        =  self.size['shortest_edge']
																								lowerCAmelCase__        =  int(self.size['shortest_edge'] * w / h				)
																		else:
																								lowerCAmelCase__        =  self.size['shortest_edge']
																								lowerCAmelCase__        =  self.size['shortest_edge']

												else:
																		lowerCAmelCase__        =  []
																		for image in image_inputs:
																								lowerCAmelCase__  ,    lowerCAmelCase__        =  self.get_expected_values([image]				)
																								expected_values.append((expected_height, expected_width)				)
																		lowerCAmelCase__        =  max(_UpperCamelCase       ,  key=lambda _UpperCamelCase				: item[0]				)[0]
																		lowerCAmelCase__        =  max(_UpperCamelCase       ,  key=lambda _UpperCamelCase				: item[1]				)[1]

												return expected_height, expected_width




@require_torch
@require_vision
class       __SCREAMING_SNAKE_CASE   (				__lowercase						,   unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:    Any						=   YolosImageProcessor if is_vision_available() else None






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  YolosImageProcessingTester(self				)






						@property
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return self.image_processor_tester.prepare_image_processor_dict()






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'image_mean'				)				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'image_std'				)				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'do_normalize'				)				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'do_resize'				)				)
												self.assertTrue(hasattr(_UpperCamelCase       ,  'size'				)				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.image_processing_class.from_dict(self.image_processor_dict				)
												self.assertEqual(image_processor.size       ,  {'shortest_edge': 18, 'longest_edge': 13_33}				)
												self.assertEqual(image_processor.do_pad       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  self.image_processing_class.from_dict(
												    self.image_processor_dict       ,  size=42       ,  max_size=84       ,  pad_and_return_pixel_mask=_UpperCamelCase				)
												self.assertEqual(image_processor.size       ,  {'shortest_edge': 42, 'longest_edge': 84}				)
												self.assertEqual(image_processor.do_pad       ,  _UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												# create random PIL images
												lowerCAmelCase__        =  prepare_image_inputs(self.image_processor_tester       ,  equal_resolution=_UpperCamelCase				)
												for image in image_inputs:
																		self.assertIsInstance(_UpperCamelCase       ,  Image.Image				)

												# Test not batched input
												lowerCAmelCase__        =  image_processing(image_inputs[0]       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)       ,  )

												# Test batched
												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase       ,  batched=_UpperCamelCase				)

												lowerCAmelCase__        =  image_processing(_UpperCamelCase       ,  return_tensors='pt'				).pixel_values
												self.assertEqual(
												    encoded_images.shape       ,  (
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        expected_height,
												        expected_width,
												    )       ,  )






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												# create random numpy tensors
												lowerCAmelCase__        =  prepare_image_inputs(self.image_processor_tester       ,  equal_resolution=_UpperCamelCase       ,  numpify=_UpperCamelCase				)
												for image in image_inputs:
																		self.assertIsInstance(_UpperCamelCase       ,  np.ndarray				)

												# Test not batched input
												lowerCAmelCase__        =  image_processing(image_inputs[0]       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)       ,  )

												# Test batched
												lowerCAmelCase__        =  image_processing(_UpperCamelCase       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase       ,  batched=_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        expected_height,
												        expected_width,
												    )       ,  )






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												# create random PyTorch tensors
												lowerCAmelCase__        =  prepare_image_inputs(self.image_processor_tester       ,  equal_resolution=_UpperCamelCase       ,  torchify=_UpperCamelCase				)
												for image in image_inputs:
																		self.assertIsInstance(_UpperCamelCase       ,  torch.Tensor				)

												# Test not batched input
												lowerCAmelCase__        =  image_processing(image_inputs[0]       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)       ,  )

												# Test batched
												lowerCAmelCase__        =  image_processing(_UpperCamelCase       ,  return_tensors='pt'				).pixel_values

												lowerCAmelCase__  ,    lowerCAmelCase__        =  self.image_processor_tester.get_expected_values(_UpperCamelCase       ,  batched=_UpperCamelCase				)

												self.assertEqual(
												    encoded_images.shape       ,  (
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        expected_height,
												        expected_width,
												    )       ,  )






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.image_processing_class(**self.image_processor_dict				)
												lowerCAmelCase__        =  self.image_processing_class(do_resize=_UpperCamelCase       ,  do_normalize=_UpperCamelCase       ,  do_rescale=_UpperCamelCase				)
												# create random PyTorch tensors
												lowerCAmelCase__        =  prepare_image_inputs(self.image_processor_tester       ,  equal_resolution=_UpperCamelCase       ,  torchify=_UpperCamelCase				)
												for image in image_inputs:
																		self.assertIsInstance(_UpperCamelCase       ,  torch.Tensor				)

												# Test whether the method "pad" and calling the image processor return the same tensors
												lowerCAmelCase__        =  image_processing_a.pad(_UpperCamelCase       ,  return_tensors='pt'				)
												lowerCAmelCase__        =  image_processing_a(_UpperCamelCase       ,  return_tensors='pt'				)

												self.assertTrue(
												    torch.allclose(encoded_images_with_method['pixel_values']       ,  encoded_images['pixel_values']       ,  atol=1E-4				)				)






						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
												with open('./tests/fixtures/tests_samples/COCO/coco_annotations.txt'       ,  'r'				) as f:
																		lowerCAmelCase__        =  json.loads(f.read()				)

												lowerCAmelCase__        =  {'image_id': 3_97_69, 'annotations': target}

												# encode them
												lowerCAmelCase__        =  YolosImageProcessor.from_pretrained('hustvl/yolos-small'				)
												lowerCAmelCase__        =  image_processing(images=_UpperCamelCase       ,  annotations=_UpperCamelCase       ,  return_tensors='pt'				)

												# verify pixel values
												lowerCAmelCase__        =  torch.Size([1, 3, 8_00, 10_66]				)
												self.assertEqual(encoding['pixel_values'].shape       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  torch.tensor([0.27_96, 0.31_38, 0.34_81]				)
												self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3]       ,  _UpperCamelCase       ,  atol=1E-4				)				)

												# verify area
												lowerCAmelCase__        =  torch.tensor([58_87.96_00, 1_12_50.20_61, 48_93_53.84_38, 83_71_22.75_00, 14_79_67.51_56, 16_57_32.34_38]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['area']       ,  _UpperCamelCase				)				)
												# verify boxes
												lowerCAmelCase__        =  torch.Size([6, 4]				)
												self.assertEqual(encoding['labels'][0]['boxes'].shape       ,  _UpperCamelCase				)
												lowerCAmelCase__        =  torch.tensor([0.55_03, 0.27_65, 0.06_04, 0.22_15]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0]       ,  _UpperCamelCase       ,  atol=1E-3				)				)
												# verify image_id
												lowerCAmelCase__        =  torch.tensor([3_97_69]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['image_id']       ,  _UpperCamelCase				)				)
												# verify is_crowd
												lowerCAmelCase__        =  torch.tensor([0, 0, 0, 0, 0, 0]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd']       ,  _UpperCamelCase				)				)
												# verify class_labels
												lowerCAmelCase__        =  torch.tensor([75, 75, 63, 65, 17, 17]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels']       ,  _UpperCamelCase				)				)
												# verify orig_size
												lowerCAmelCase__        =  torch.tensor([4_80, 6_40]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size']       ,  _UpperCamelCase				)				)
												# verify size
												lowerCAmelCase__        =  torch.tensor([8_00, 10_66]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['size']       ,  _UpperCamelCase				)				)







						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
												with open('./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt'       ,  'r'				) as f:
																		lowerCAmelCase__        =  json.loads(f.read()				)

												lowerCAmelCase__        =  {'file_name': '000000039769.png', 'image_id': 3_97_69, 'segments_info': target}

												lowerCAmelCase__        =  pathlib.Path('./tests/fixtures/tests_samples/COCO/coco_panoptic'				)

												# encode them
												lowerCAmelCase__        =  YolosImageProcessor(format='coco_panoptic'				)
												lowerCAmelCase__        =  image_processing(images=_UpperCamelCase       ,  annotations=_UpperCamelCase       ,  masks_path=_UpperCamelCase       ,  return_tensors='pt'				)

												# verify pixel values
												lowerCAmelCase__        =  torch.Size([1, 3, 8_00, 10_66]				)
												self.assertEqual(encoding['pixel_values'].shape       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  torch.tensor([0.27_96, 0.31_38, 0.34_81]				)
												self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3]       ,  _UpperCamelCase       ,  atol=1E-4				)				)

												# verify area
												lowerCAmelCase__        =  torch.tensor([14_79_79.68_75, 16_55_27.04_69, 48_46_38.59_38, 1_12_92.93_75, 58_79.65_62, 76_34.11_47]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['area']       ,  _UpperCamelCase				)				)
												# verify boxes
												lowerCAmelCase__        =  torch.Size([6, 4]				)
												self.assertEqual(encoding['labels'][0]['boxes'].shape       ,  _UpperCamelCase				)
												lowerCAmelCase__        =  torch.tensor([0.26_25, 0.54_37, 0.46_88, 0.86_25]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0]       ,  _UpperCamelCase       ,  atol=1E-3				)				)
												# verify image_id
												lowerCAmelCase__        =  torch.tensor([3_97_69]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['image_id']       ,  _UpperCamelCase				)				)
												# verify is_crowd
												lowerCAmelCase__        =  torch.tensor([0, 0, 0, 0, 0, 0]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd']       ,  _UpperCamelCase				)				)
												# verify class_labels
												lowerCAmelCase__        =  torch.tensor([17, 17, 63, 75, 75, 93]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels']       ,  _UpperCamelCase				)				)
												# verify masks
												lowerCAmelCase__        =  82_28_73
												self.assertEqual(encoding['labels'][0]['masks'].sum().item()       ,  _UpperCamelCase				)
												# verify orig_size
												lowerCAmelCase__        =  torch.tensor([4_80, 6_40]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size']       ,  _UpperCamelCase				)				)
												# verify size
												lowerCAmelCase__        =  torch.tensor([8_00, 10_66]				)
												self.assertTrue(torch.allclose(encoding['labels'][0]['size']       ,  _UpperCamelCase				)				)













import unittest

from transformers import BarthezTokenizer, BarthezTokenizerFast, BatchEncoding
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
@require_sentencepiece
@slow  # see https://github.com/huggingface/transformers/issues/11457
class       __SCREAMING_SNAKE_CASE   (				__lowercase						,   unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:    Tuple						=   BarthezTokenizer
						_SCREAMING_SNAKE_CASE		:    int						=   BarthezTokenizerFast
						_SCREAMING_SNAKE_CASE		:    Dict						=   True
						_SCREAMING_SNAKE_CASE		:    Tuple						=   True






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												super().setUp()

												lowerCAmelCase__        =  BarthezTokenizerFast.from_pretrained('moussaKam/mbarthez'				)
												tokenizer.save_pretrained(self.tmpdirname				)
												tokenizer.save_pretrained(self.tmpdirname       ,  legacy_format=_UpperCamelCase				)
												lowerCAmelCase__        =  tokenizer






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  '<pad>'
												lowerCAmelCase__        =  1

												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"""
												lowerCAmelCase__        =  list(self.get_tokenizer().get_vocab().keys()				)

												self.assertEqual(vocab_keys[0]       ,  '<s>'				)
												self.assertEqual(vocab_keys[1]       ,  '<pad>'				)
												self.assertEqual(vocab_keys[-1]       ,  '<mask>'				)
												self.assertEqual(len(_UpperCamelCase				)       ,  10_11_22				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												self.assertEqual(self.get_tokenizer().vocab_size       ,  10_11_22				)






						@require_torch
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  ['A long paragraph for summarization.', 'Another paragraph for summarization.']
												lowerCAmelCase__        =  [0, 57, 30_18, 7_03_07, 91, 2]

												lowerCAmelCase__        =  self.tokenizer(
												    _UpperCamelCase       ,  max_length=len(_UpperCamelCase				)       ,  padding=_UpperCamelCase       ,  truncation=_UpperCamelCase       ,  return_tensors='pt'				)
												self.assertIsInstance(_UpperCamelCase       ,  _UpperCamelCase				)

												self.assertEqual((2, 6)       ,  batch.input_ids.shape				)
												self.assertEqual((2, 6)       ,  batch.attention_mask.shape				)
												lowerCAmelCase__        =  batch.input_ids.tolist()[0]
												self.assertListEqual(_UpperCamelCase       ,  _UpperCamelCase				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												if not self.test_rust_tokenizer:
																		return

												lowerCAmelCase__        =  self.get_tokenizer()
												lowerCAmelCase__        =  self.get_rust_tokenizer()

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

												lowerCAmelCase__        =  tokenizer.tokenize(_UpperCamelCase				)
												lowerCAmelCase__        =  rust_tokenizer.tokenize(_UpperCamelCase				)
												self.assertListEqual(_UpperCamelCase       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  tokenizer.encode(_UpperCamelCase       ,  add_special_tokens=_UpperCamelCase				)
												lowerCAmelCase__        =  rust_tokenizer.encode(_UpperCamelCase       ,  add_special_tokens=_UpperCamelCase				)
												self.assertListEqual(_UpperCamelCase       ,  _UpperCamelCase				)

												lowerCAmelCase__        =  self.get_rust_tokenizer()
												lowerCAmelCase__        =  tokenizer.encode(_UpperCamelCase				)
												lowerCAmelCase__        =  rust_tokenizer.encode(_UpperCamelCase				)
												self.assertListEqual(_UpperCamelCase       ,  _UpperCamelCase				)







						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												# fmt: off
												lowerCAmelCase__        =  {'input_ids': [[0, 4_90, 1_43_28, 45_07, 3_54, 47, 4_36_69, 95, 25, 7_81_17, 2_02_15, 1_97_79, 1_90, 22, 4_00, 4, 3_53_43, 8_03_10, 6_03, 86, 2_49_37, 1_05, 3_34_38, 9_47_62, 1_96, 3_96_42, 7, 15, 1_59_33, 1_73, 2, 1, 1, 1, 1, 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, 1_05_34, 87, 25, 66, 33_58, 1_96, 5_52_89, 8, 8_29_61, 81, 22_04, 7_52_03, 7, 15, 7_63, 1_29_56, 2_16, 1_78, 1_43_28, 95_95, 13_77, 6_96_93, 7, 4_48, 7_10_21, 1_96, 1_81_06, 14_37, 1_39_74, 1_08, 90_83, 4, 4_93_15, 7, 39, 86, 13_26, 27_93, 4_63_33, 4, 4_48, 1_96, 7_45_88, 7, 4_93_15, 7, 39, 21, 8_22, 3_84_70, 74, 21, 6_67_23, 6_24_80, 8, 2_20_50, 5, 2]], '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, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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

												# moussaKam/mbarthez is a french model. So we also use french texts.
												lowerCAmelCase__        =  [
												    '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=_UpperCamelCase       ,  model_name='moussaKam/mbarthez'       ,  revision='c2e4ecbca5e3cd2c37fe1ac285ca4fbdf1366fb6'       ,  sequences=_UpperCamelCase       ,  )





