'''simple docstring'''





import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
	import tensorflow as tf
	from tensorflow.python.framework.errors_impl import ResourceExhaustedError

	from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
	import pyanvml.pyanvml as nvml

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


def     __lowerCAmelCase						(       a_       ,      a_		)      ->	List[Any]:





					'''simple docstring'''





					def run_func(a_		):
										@wraps(A__		)
										def run_in_eager_mode(*a_       ,      **a_		):
															return func(*A__       ,      **A__		)

										@wraps(A__		)
										@tf.function(experimental_compile=A__		)
										def run_in_graph_mode(*a_       ,      **a_		):
															return func(*A__       ,      **A__		)

										if do_eager_mode is True:
															if use_xla is not False:
																				raise ValueError(
																				    'Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`.'		)
															return run_in_eager_mode
										else:
															return run_in_graph_mode

					return run_func


def     __lowerCAmelCase						(       a_       ,      a_       ,      a_		)      ->	int:





					'''simple docstring'''





					SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       random.Random()
					SCREAMING_SNAKE_CASE					:			Optional[int]    	=       [rng.randint(0       ,      vocab_size - 1		) for i in range(batch_size * sequence_length		)]
					return tf.constant(A__       ,      shape=(batch_size, sequence_length)       ,      dtype=tf.intaa		)






class 				UpperCAmelCase (       __lowerCamelCase ):




				'''simple docstring'''







				snake_case__							:   TensorFlowBenchmarkArguments
				snake_case__							:   PretrainedConfig
				snake_case__							:   str							=						"TensorFlow"






				@property
				def       _UpperCamelCase    (       self )							-> Optional[Any]:
									return tf.__version__






				def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__    ,							lowercase__ )							-> int:
									# initialize GPU on separate process
									SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       self.args.strategy
									if strategy is None:
														raise ValueError('A device strategy has to be initialized before using TensorFlow.' )
									SCREAMING_SNAKE_CASE					:			List[str]    	=       self._prepare_inference_func(UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_ )
									return self._measure_speed(_inference )






				def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__    ,							lowercase__ )							-> List[Any]:
									SCREAMING_SNAKE_CASE					:			str    	=       self.args.strategy
									if strategy is None:
														raise ValueError('A device strategy has to be initialized before using TensorFlow.' )
									SCREAMING_SNAKE_CASE					:			Dict    	=       self._prepare_train_func(UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_ )
									return self._measure_speed(_train )






				def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__    ,							lowercase__ )							-> int:
									# initialize GPU on separate process
									if self.args.is_gpu:
														tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]    ,							UpperCamelCase_ )
									SCREAMING_SNAKE_CASE					:			str    	=       self.args.strategy
									if strategy is None:
														raise ValueError('A device strategy has to be initialized before using TensorFlow.' )
									SCREAMING_SNAKE_CASE					:			List[Any]    	=       self._prepare_inference_func(UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_ )
									return self._measure_memory(_inference )






				def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__    ,							lowercase__ )							-> Union[str, Any]:
									if self.args.is_gpu:
														tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]    ,							UpperCamelCase_ )
									SCREAMING_SNAKE_CASE					:			Any    	=       self.args.strategy
									if strategy is None:
														raise ValueError('A device strategy has to be initialized before using TensorFlow.' )

									SCREAMING_SNAKE_CASE					:			str    	=       self._prepare_train_func(UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_ )
									return self._measure_memory(_train )






				def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__    ,							lowercase__ )							-> Optional[int]:
									SCREAMING_SNAKE_CASE					:			Any    	=       self.config_dict[model_name]

									if self.args.fpaa:
														raise NotImplementedError('Mixed precision is currently not supported.' )

									SCREAMING_SNAKE_CASE					:			List[str]    	=       (
									    hasattr(UpperCamelCase_    ,							'architectures' )
									    and isinstance(config.architectures    ,							UpperCamelCase_ )
									    and len(config.architectures ) > 0
									)
									if not self.args.only_pretrain_model and has_model_class_in_config:
														try:
																			SCREAMING_SNAKE_CASE					:			Any    	=       'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
																			SCREAMING_SNAKE_CASE					:			Tuple    	=       __import__('transformers'    ,							fromlist=[model_class] )
																			SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       getattr(UpperCamelCase_    ,							UpperCamelCase_ )
																			SCREAMING_SNAKE_CASE					:			Any    	=       model_cls(UpperCamelCase_ )
														except ImportError:
																			raise ImportError(
																			    F"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
																			    ' set `--only_pretrain_model` or `args.only_pretrain_model=True`.' )
									else:
														SCREAMING_SNAKE_CASE					:			Tuple    	=       TF_MODEL_MAPPING[config.__class__](UpperCamelCase_ )

									# encoder-decoder has vocab size saved differently
									SCREAMING_SNAKE_CASE					:			Optional[int]    	=       config.vocab_size if hasattr(UpperCamelCase_    ,							'vocab_size' ) else config.encoder.vocab_size
									SCREAMING_SNAKE_CASE					:			Tuple    	=       random_input_ids(UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_ )

									@run_with_tf_optimizations(self.args.eager_mode    ,							self.args.use_xla )
									def encoder_decoder_forward():
														return model(UpperCamelCase_    ,							decoder_input_ids=UpperCamelCase_    ,							training=UpperCamelCase_ )

									@run_with_tf_optimizations(self.args.eager_mode    ,							self.args.use_xla )
									def encoder_forward():
														return model(UpperCamelCase_    ,							training=UpperCamelCase_ )

									SCREAMING_SNAKE_CASE					:			Dict    	=       encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

									return _inference






				def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__    ,							lowercase__ )							-> Dict:
									SCREAMING_SNAKE_CASE					:			str    	=       self.config_dict[model_name]

									if self.args.eager_mode is not False:
														raise ValueError('Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`.' )

									if self.args.fpaa:
														raise NotImplementedError('Mixed precision is currently not supported.' )

									SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       (
									    hasattr(UpperCamelCase_    ,							'architectures' )
									    and isinstance(config.architectures    ,							UpperCamelCase_ )
									    and len(config.architectures ) > 0
									)
									if not self.args.only_pretrain_model and has_model_class_in_config:
														try:
																			SCREAMING_SNAKE_CASE					:			List[str]    	=       'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
																			SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       __import__('transformers'    ,							fromlist=[model_class] )
																			SCREAMING_SNAKE_CASE					:			Optional[int]    	=       getattr(UpperCamelCase_    ,							UpperCamelCase_ )
																			SCREAMING_SNAKE_CASE					:			Dict    	=       model_cls(UpperCamelCase_ )
														except ImportError:
																			raise ImportError(
																			    F"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
																			    ' set `--only_pretrain_model` or `args.only_pretrain_model=True`.' )
									else:
														SCREAMING_SNAKE_CASE					:			Tuple    	=       TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](UpperCamelCase_ )

									# encoder-decoder has vocab size saved differently
									SCREAMING_SNAKE_CASE					:			List[Any]    	=       config.vocab_size if hasattr(UpperCamelCase_    ,							'vocab_size' ) else config.encoder.vocab_size
									SCREAMING_SNAKE_CASE					:			Dict    	=       random_input_ids(UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_ )

									@run_with_tf_optimizations(self.args.eager_mode    ,							self.args.use_xla )
									def encoder_decoder_train():
														SCREAMING_SNAKE_CASE					:			int    	=       model(UpperCamelCase_    ,							decoder_input_ids=UpperCamelCase_    ,							labels=UpperCamelCase_    ,							training=UpperCamelCase_ )[0]
														SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       tf.gradients(UpperCamelCase_    ,							model.trainable_variables )
														return gradients

									@run_with_tf_optimizations(self.args.eager_mode    ,							self.args.use_xla )
									def encoder_train():
														SCREAMING_SNAKE_CASE					:			Optional[int]    	=       model(UpperCamelCase_    ,							labels=UpperCamelCase_    ,							training=UpperCamelCase_ )[0]
														SCREAMING_SNAKE_CASE					:			Any    	=       tf.gradients(UpperCamelCase_    ,							model.trainable_variables )
														return gradients

									SCREAMING_SNAKE_CASE					:			Dict    	=       encoder_decoder_train if config.is_encoder_decoder else encoder_train

									return _train






				def       _UpperCamelCase    (       self    ,							lowercase__ )							-> str:
									with self.args.strategy.scope():
														try:
																			if self.args.is_tpu or self.args.use_xla:
																								# run additional 10 times to stabilize compilation for tpu
																								logger.info('Do inference on TPU. Running model 5 times to stabilize compilation' )
																								timeit.repeat(UpperCamelCase_    ,							repeat=1    ,							number=5 )

																			# as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
																			SCREAMING_SNAKE_CASE					:			str    	=       timeit.repeat(
																			    UpperCamelCase_    ,							repeat=self.args.repeat    ,							number=10    ,							)

																			return min(UpperCamelCase_ ) / 1_0.0
														except ResourceExhaustedError as e:
																			self.print_fn(F"""Doesn\'t fit on GPU. {e}""" )






				def       _UpperCamelCase    (       self    ,							lowercase__ )							-> int:
									logger.info(
									    'Note that TensorFlow allocates more memory than '
									    'it might need to speed up computation. '
									    'The memory reported here corresponds to the memory '
									    'reported by `nvidia-smi`, which can vary depending '
									    'on total available memory on the GPU that is used.' )
									with self.args.strategy.scope():
														try:
																			if self.args.trace_memory_line_by_line:
																								if not self.args.eager_mode:
																													raise ValueError(
																													    '`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory'
																													    ' consumption line by line.' )
																								SCREAMING_SNAKE_CASE					:			str    	=       start_memory_tracing('transformers' )

																			if self.args.is_tpu:
																								# tpu
																								raise NotImplementedError(
																								    'Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking'
																								    ' with `args.memory=False`' )
																			elif self.args.is_gpu:
																								# gpu
																								if not is_pyanvml_available():
																													logger.warning(
																													    'py3nvml not installed, we won\'t log GPU memory usage. '
																													    'Install py3nvml (pip install py3nvml) to log information about GPU.' )
																													SCREAMING_SNAKE_CASE					:			Optional[int]    	=       'N/A'
																								else:
																													logger.info(
																													    'Measuring total GPU usage on GPU device. Make sure to not have additional processes'
																													    ' running on the same GPU.' )
																													# init nvml
																													nvml.nvmlInit()
																													func()
																													SCREAMING_SNAKE_CASE					:			Any    	=       nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx )
																													SCREAMING_SNAKE_CASE					:			int    	=       nvml.nvmlDeviceGetMemoryInfo(UpperCamelCase_ )
																													SCREAMING_SNAKE_CASE					:			Optional[int]    	=       meminfo.used
																													SCREAMING_SNAKE_CASE					:			Dict    	=       Memory(UpperCamelCase_ )
																													# shutdown nvml
																													nvml.nvmlShutdown()
																			else:
																								# cpu
																								if self.args.trace_memory_line_by_line:
																													logger.info(
																													    'When enabling line by line tracing, the max peak memory for CPU is inaccurate in'
																													    ' TensorFlow.' )
																													SCREAMING_SNAKE_CASE					:			Tuple    	=       None
																								else:
																													SCREAMING_SNAKE_CASE					:			Optional[int]    	=       measure_peak_memory_cpu(UpperCamelCase_ )
																													SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       Memory(UpperCamelCase_ ) if isinstance(UpperCamelCase_    ,							UpperCamelCase_ ) else memory_bytes
																			if self.args.trace_memory_line_by_line:
																								SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       stop_memory_tracing(UpperCamelCase_ )
																								if memory is None:
																													SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       summary.total
																			else:
																								SCREAMING_SNAKE_CASE					:			List[Any]    	=       None

																			return memory, summary
														except ResourceExhaustedError as e:
																			self.print_fn(F"""Doesn\'t fit on GPU. {e}""" )
																			return "N/A", None




'''simple docstring'''





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 				UpperCAmelCase (       _SCREAMING_SNAKE_CASE   ,    unittest.TestCase ):




    '''simple docstring'''







    snake_case__							:   int							=						CLIPTokenizer
    snake_case__							:   Union[str, Any]							=						CLIPTokenizerFast
    snake_case__							:   str							=						True
    snake_case__							:   Optional[int]							=						{}
    snake_case__							:   int							=						False






    def       _UpperCamelCase    (       self )							-> Tuple:
         super().setUp()

         # fmt: off
         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       ['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
         SCREAMING_SNAKE_CASE					:			int    	=       dict(zip(lowercase__    ,							range(len(lowercase__ ) ) ) )
         SCREAMING_SNAKE_CASE					:			Dict    	=       ['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>']
         SCREAMING_SNAKE_CASE					:			List[str]    	=       {'unk_token': '<unk>'}

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






    def       _UpperCamelCase    (       self    ,							**lowercase__ )							-> Dict:
         kwargs.update(self.special_tokens_map )
         return CLIPTokenizer.from_pretrained(self.tmpdirname    ,							**lowercase__ )






    def       _UpperCamelCase    (       self    ,							**lowercase__ )							-> Union[str, Any]:
         kwargs.update(self.special_tokens_map )
         return CLIPTokenizerFast.from_pretrained(self.tmpdirname    ,							**lowercase__ )






    def       _UpperCamelCase    (       self    ,							lowercase__ )							-> List[Any]:
         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       'lower newer'
         SCREAMING_SNAKE_CASE					:			Dict    	=       'lower newer'
         return input_text, output_text






    def       _UpperCamelCase    (       self )							-> List[Any]:
         SCREAMING_SNAKE_CASE					:			str    	=       CLIPTokenizer(self.vocab_file    ,							self.merges_file    ,							**self.special_tokens_map )
         SCREAMING_SNAKE_CASE					:			Optional[int]    	=       'lower newer'
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       ['lo', 'w', 'er</w>', 'n', 'e', 'w', 'er</w>']
         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       tokenizer.tokenize(lowercase__ )
         self.assertListEqual(lowercase__    ,							lowercase__ )

         SCREAMING_SNAKE_CASE					:			Any    	=       tokens + [tokenizer.unk_token]
         SCREAMING_SNAKE_CASE					:			int    	=       [10, 2, 16, 9, 3, 2, 16, 20]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase__ )    ,							lowercase__ )






    @require_ftfy
    def       _UpperCamelCase    (       self )							-> List[str]:
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})""" ):
                   SCREAMING_SNAKE_CASE					:			Dict    	=       self.tokenizer_class.from_pretrained(lowercase__    ,							**lowercase__ )
                   SCREAMING_SNAKE_CASE					:			List[Any]    	=       self.rust_tokenizer_class.from_pretrained(lowercase__    ,							**lowercase__ )

                   SCREAMING_SNAKE_CASE					:			Tuple    	=       'A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'
                   SCREAMING_SNAKE_CASE					:			List[str]    	=       tokenizer_s.tokenize(lowercase__ )
                   SCREAMING_SNAKE_CASE					:			List[str]    	=       tokenizer_r.tokenize(lowercase__ )

                   self.assertListEqual(lowercase__    ,							lowercase__ )

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

                   self.assertListEqual(lowercase__    ,							lowercase__ )

                   # Test that the tokenization is identical on unicode of space type
                   SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       [
                       '\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:
                        SCREAMING_SNAKE_CASE					:			Tuple    	=       tokenizer_s.tokenize(lowercase__ )
                        SCREAMING_SNAKE_CASE					:			Optional[int]    	=       tokenizer_r.tokenize(lowercase__ )

                        self.assertListEqual(lowercase__    ,							lowercase__ )

                   # Test that the tokenization is identical on unicode of line break type
                   SCREAMING_SNAKE_CASE					:			int    	=       [
                       '\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:
                        SCREAMING_SNAKE_CASE					:			List[Any]    	=       tokenizer_s.tokenize(lowercase__ )
                        SCREAMING_SNAKE_CASE					:			int    	=       tokenizer_r.tokenize(lowercase__ )

                        self.assertListEqual(lowercase__    ,							lowercase__ )






    def       _UpperCamelCase    (       self )							-> int:
         # 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})""" ):
                   SCREAMING_SNAKE_CASE					:			str    	=       'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
                   SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       F"""{text_of_1_token} {text_of_1_token}"""

                   SCREAMING_SNAKE_CASE					:			List[str]    	=       self.rust_tokenizer_class.from_pretrained(
                       lowercase__    ,							use_fast=lowercase__    ,							)
                   SCREAMING_SNAKE_CASE					:			Tuple    	=       tokenizer_r(lowercase__    ,							return_offsets_mapping=lowercase__    ,							add_special_tokens=lowercase__ )
                   self.assertEqual(encoding.offset_mapping[0]    ,							(0, len(lowercase__ )) )
                   self.assertEqual(
                       encoding.offset_mapping[1]    ,							(len(lowercase__ ) + 1, len(lowercase__ ) + 1 + len(lowercase__ ))    ,							)

                   SCREAMING_SNAKE_CASE					:			Optional[int]    	=       F""" {text}"""

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






    def       _UpperCamelCase    (       self )							-> int:
         # 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(lowercase__ ) 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       _UpperCamelCase    (       self )							-> Union[str, Any]:
         super().test_tokenization_python_rust_equals()






    def       _UpperCamelCase    (       self )							-> int:
         # CLIP always lower cases letters
         pass



