
'''simple docstring'''







import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import (
							    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
							    TimesformerForVideoClassification,
							    TimesformerModel,
							)
							from transformers.models.timesformer.modeling_timesformer import TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from transformers import VideoMAEImageProcessor






class 			lowerCAmelCase__       :






					"""simple docstring"""




					def __init__(       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE=13    ,							__SCREAMING_SNAKE_CASE=10    ,							__SCREAMING_SNAKE_CASE=3    ,							__SCREAMING_SNAKE_CASE=2    ,							__SCREAMING_SNAKE_CASE=2    ,							__SCREAMING_SNAKE_CASE=True    ,							__SCREAMING_SNAKE_CASE=True    ,							__SCREAMING_SNAKE_CASE=32    ,							__SCREAMING_SNAKE_CASE=5    ,							__SCREAMING_SNAKE_CASE=4    ,							__SCREAMING_SNAKE_CASE=37    ,							__SCREAMING_SNAKE_CASE="gelu"    ,							__SCREAMING_SNAKE_CASE=0.1    ,							__SCREAMING_SNAKE_CASE=0.1    ,							__SCREAMING_SNAKE_CASE=10    ,							__SCREAMING_SNAKE_CASE=0.02    ,							__SCREAMING_SNAKE_CASE="divided_space_time"    ,							__SCREAMING_SNAKE_CASE=None    ,							):


											"""simple docstring"""





											lowercase_     :					List[Any]													=	parent
											lowercase_     :					List[str]													=	batch_size
											lowercase_     :					Union[str, Any]													=	image_size
											lowercase_     :					List[Any]													=	num_channels
											lowercase_     :					List[str]													=	patch_size
											lowercase_     :					List[str]													=	num_frames
											lowercase_     :					Union[str, Any]													=	is_training
											lowercase_     :					List[str]													=	use_labels
											lowercase_     :					str													=	hidden_size
											lowercase_     :					Union[str, Any]													=	num_hidden_layers
											lowercase_     :					Union[str, Any]													=	num_attention_heads
											lowercase_     :					Dict													=	intermediate_size
											lowercase_     :					Tuple													=	hidden_act
											lowercase_     :					Optional[Any]													=	hidden_dropout_prob
											lowercase_     :					Optional[int]													=	attention_probs_dropout_prob
											lowercase_     :					Union[str, Any]													=	attention_type
											lowercase_     :					Optional[Any]													=	initializer_range
											lowercase_     :					Optional[Any]													=	scope
											lowercase_     :					Optional[int]													=	num_labels

											# in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
											lowercase_     :					str													=	(image_size // patch_size) ** 2
											lowercase_     :					Optional[Any]													=	(num_frames) * self.num_patches_per_frame + 1






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Optional[int]													=	floats_tensor(
											    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]		)

											lowercase_     :					int													=	None
											if self.use_labels:
																	lowercase_     :					Optional[Any]													=	ids_tensor([self.batch_size]    ,							self.num_labels		)

											lowercase_     :					int													=	self.get_config()

											return config, pixel_values, labels






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Any													=	TimesformerConfig(
											    image_size=self.image_size    ,							patch_size=self.patch_size    ,							num_channels=self.num_channels    ,							num_frames=self.num_frames    ,							hidden_size=self.hidden_size    ,							num_hidden_layers=self.num_hidden_layers    ,							num_attention_heads=self.num_attention_heads    ,							intermediate_size=self.intermediate_size    ,							hidden_act=self.hidden_act    ,							hidden_dropout_prob=self.hidden_dropout_prob    ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,							initializer_range=self.initializer_range    ,							attention_type=self.attention_type    ,							)
											lowercase_     :					str													=	self.num_labels
											return config






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					Optional[int]													=	TimesformerModel(config=__SCREAMING_SNAKE_CASE		)
											model.to(__SCREAMING_SNAKE_CASE		)
											model.eval()
											lowercase_     :					Tuple													=	model(__SCREAMING_SNAKE_CASE		)
											self.parent.assertEqual(result.last_hidden_state.shape    ,							(self.batch_size, self.seq_length, self.hidden_size)		)






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					Any													=	TimesformerForVideoClassification(__SCREAMING_SNAKE_CASE		)
											model.to(__SCREAMING_SNAKE_CASE		)
											model.eval()

											lowercase_     :					Optional[int]													=	model(__SCREAMING_SNAKE_CASE		)

											# verify the logits shape
											lowercase_     :					Dict													=	torch.Size((self.batch_size, self.num_labels)		)
											self.parent.assertEqual(result.logits.shape    ,							__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Optional[Any]													=	self.prepare_config_and_inputs()
											lowercase_     :					Tuple													=	config_and_inputs
											lowercase_     :					List[Any]													=	{"""pixel_values""": pixel_values}
											return config, inputs_dict







@require_torch
class 			lowerCAmelCase__       (  __lowercase   ,						__lowercase   ,						unittest.TestCase					):






					"""simple docstring"""




					lowerCAmelCase_					       =					(TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
					lowerCAmelCase_					       =					(
					    {'''feature-extraction''': TimesformerModel, '''video-classification''': TimesformerForVideoClassification}
					    if is_torch_available()
					    else {}
					)

					lowerCAmelCase_					       =					False
					lowerCAmelCase_					       =					False
					lowerCAmelCase_					       =					False
					lowerCAmelCase_					       =					False






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					List[str]													=	TimesformerModelTester(self		)
											lowercase_     :					List[Any]													=	ConfigTester(
											    self    ,							config_class=__SCREAMING_SNAKE_CASE    ,							has_text_modality=__SCREAMING_SNAKE_CASE    ,							hidden_size=37		)






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE=False		):


											"""simple docstring"""





											lowercase_     :					Dict													=	copy.deepcopy(__SCREAMING_SNAKE_CASE		)

											if return_labels:
																	if model_class in get_values(__SCREAMING_SNAKE_CASE		):
																							lowercase_     :					List[str]													=	torch.zeros(
																							    self.model_tester.batch_size    ,							dtype=torch.long    ,							device=__SCREAMING_SNAKE_CASE		)

											return inputs_dict






					def      _snake_case   (       self		):


											"""simple docstring"""





											self.config_tester.run_common_tests()






					@unittest.skip(reason='''TimeSformer does not use inputs_embeds'''		)
					def      _snake_case   (       self		):


											"""simple docstring"""





											pass






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					int													=	self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowercase_     :					str													=	model_class(__SCREAMING_SNAKE_CASE		)
																	self.assertIsInstance(model.get_input_embeddings()    ,							(nn.Module)		)
																	lowercase_     :					Tuple													=	model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE    ,							nn.Linear		)		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Any													=	self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowercase_     :					Union[str, Any]													=	model_class(__SCREAMING_SNAKE_CASE		)
																	lowercase_     :					Optional[Any]													=	inspect.signature(model.forward		)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	lowercase_     :					Union[str, Any]													=	[*signature.parameters.keys()]

																	lowercase_     :					str													=	["""pixel_values"""]
																	self.assertListEqual(arg_names[:1]    ,							__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					str													=	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Dict													=	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_video_classification(*__SCREAMING_SNAKE_CASE		)






					@slow
					def      _snake_case   (       self		):


											"""simple docstring"""





											for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase_     :					int													=	TimesformerModel.from_pretrained(__SCREAMING_SNAKE_CASE		)
																	self.assertIsNotNone(__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											if not self.has_attentions:
																	pass

											else:
																	lowercase_     :					Tuple													=	self.model_tester.prepare_config_and_inputs_for_common()
																	lowercase_     :					Dict													=	True

																	for model_class in self.all_model_classes:
																							lowercase_     :					List[str]													=	self.model_tester.seq_length
																							lowercase_     :					Tuple													=	self.model_tester.num_frames

																							lowercase_     :					str													=	True
																							lowercase_     :					List[str]													=	False
																							lowercase_     :					Tuple													=	True
																							lowercase_     :					str													=	model_class(__SCREAMING_SNAKE_CASE		)
																							model.to(__SCREAMING_SNAKE_CASE		)
																							model.eval()
																							with torch.no_grad():
																													lowercase_     :					List[str]													=	model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)		)
																							lowercase_     :					Dict													=	outputs.attentions
																							self.assertEqual(len(__SCREAMING_SNAKE_CASE		)    ,							self.model_tester.num_hidden_layers		)

																							# check that output_attentions also work using config
																							del inputs_dict["output_attentions"]
																							lowercase_     :					Optional[int]													=	True
																							lowercase_     :					Any													=	model_class(__SCREAMING_SNAKE_CASE		)
																							model.to(__SCREAMING_SNAKE_CASE		)
																							model.eval()
																							with torch.no_grad():
																													lowercase_     :					Union[str, Any]													=	model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)		)
																							lowercase_     :					int													=	outputs.attentions
																							self.assertEqual(len(__SCREAMING_SNAKE_CASE		)    ,							self.model_tester.num_hidden_layers		)

																							# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
																							self.assertListEqual(
																							    list(attentions[0].shape[-3:]		)    ,							[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]    ,							)
																							lowercase_     :					int													=	len(__SCREAMING_SNAKE_CASE		)

																							# Check attention is always last and order is fine
																							lowercase_     :					Optional[int]													=	True
																							lowercase_     :					Optional[int]													=	True
																							lowercase_     :					Union[str, Any]													=	model_class(__SCREAMING_SNAKE_CASE		)
																							model.to(__SCREAMING_SNAKE_CASE		)
																							model.eval()
																							with torch.no_grad():
																													lowercase_     :					Dict													=	model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)		)

																							self.assertEqual(out_len + 1    ,							len(__SCREAMING_SNAKE_CASE		)		)

																							lowercase_     :					List[Any]													=	outputs.attentions

																							self.assertEqual(len(__SCREAMING_SNAKE_CASE		)    ,							self.model_tester.num_hidden_layers		)

																							# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
																							self.assertListEqual(
																							    list(self_attentions[0].shape[-3:]		)    ,							[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]    ,							)






					def      _snake_case   (       self		):


											"""simple docstring"""





											def check_hidden_states_output(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		):
																	lowercase_     :					str													=	model_class(__SCREAMING_SNAKE_CASE		)
																	model.to(__SCREAMING_SNAKE_CASE		)
																	model.eval()

																	with torch.no_grad():
																							lowercase_     :					Tuple													=	model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)		)

																	lowercase_     :					int													=	outputs.hidden_states
																	lowercase_     :					Dict													=	self.model_tester.num_hidden_layers + 1
																	self.assertEqual(len(__SCREAMING_SNAKE_CASE		)    ,							__SCREAMING_SNAKE_CASE		)

																	lowercase_     :					int													=	self.model_tester.seq_length

																	self.assertListEqual(
																	    list(hidden_states[0].shape[-2:]		)    ,							[seq_length, self.model_tester.hidden_size]    ,							)

											lowercase_     :					Any													=	self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	lowercase_     :					Dict													=	True
																	check_hidden_states_output(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	lowercase_     :					str													=	True

																	check_hidden_states_output(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)







def  snake_case_		(    ):



						"""simple docstring"""





						lowercase_     :					Optional[Any]													=	hf_hub_download(
						    repo_id='''hf-internal-testing/spaghetti-video'''				,				filename='''eating_spaghetti.npy'''				,				repo_type='''dataset'''							)
						lowercase_     :					List[Any]													=	np.load(_lowerCamelCase							)
						return list(_lowerCamelCase							)






@require_torch
@require_vision
class 			lowerCAmelCase__       (  unittest.TestCase					):






					"""simple docstring"""




					@cached_property
					def      _snake_case   (       self		):


											"""simple docstring"""





											return (
											    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]    ,							image_std=[0.5, 0.5, 0.5]		)
											    if is_vision_available()
											    else None
											)






					@slow
					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					int													=	TimesformerForVideoClassification.from_pretrained('''facebook/timesformer-base-finetuned-k400'''		).to(
											    __SCREAMING_SNAKE_CASE		)

											lowercase_     :					Union[str, Any]													=	self.default_image_processor
											lowercase_     :					Dict													=	prepare_video()
											lowercase_     :					Any													=	image_processor(video[:8]    ,							return_tensors='''pt'''		).to(__SCREAMING_SNAKE_CASE		)

											# forward pass
											with torch.no_grad():
																	lowercase_     :					Any													=	model(**__SCREAMING_SNAKE_CASE		)

											# verify the logits
											lowercase_     :					int													=	torch.Size((1, 4_00)		)
											self.assertEqual(outputs.logits.shape    ,							__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Any													=	torch.tensor([-0.3_016, -0.7_713, -0.4_205]		).to(__SCREAMING_SNAKE_CASE		)

											self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,							__SCREAMING_SNAKE_CASE    ,							atol=1E-4		)		)





'''simple docstring'''







import unittest

from datasets import load_dataset

from transformers import BloomTokenizerFast
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class 			lowerCAmelCase__       (  lowerCamelCase_   ,						unittest.TestCase					):
					lowerCAmelCase_					       =					None
					lowerCAmelCase_					       =					BloomTokenizerFast
					lowerCAmelCase_					       =					BloomTokenizerFast
					lowerCAmelCase_					       =					True
					lowerCAmelCase_					       =					False
					lowerCAmelCase_					       =					'''tokenizer_file'''
					lowerCAmelCase_					       =					{'''bos_token''': '''<s>''', '''eos_token''': '''</s>''', '''unk_token''': '''<unk>''', '''pad_token''': '''<pad>'''}






					def      _snake_case   (       self		):


											"""simple docstring"""





											super().setUp()
											lowercase_     :					List[Any]													=	BloomTokenizerFast.from_pretrained('''bigscience/tokenizer'''		)
											tokenizer.save_pretrained(self.tmpdirname		)






					def      _snake_case   (       self    ,							**__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											kwargs.update(self.special_tokens_map		)
											return BloomTokenizerFast.from_pretrained(self.tmpdirname    ,							**__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Tuple													=	self.get_rust_tokenizer()

											lowercase_     :					Optional[Any]													=	['''The quick brown fox</s>''', '''jumps over the lazy dog</s>''']
											lowercase_     :					Union[str, Any]													=	[[21_75, 2_37_14, 7_31_73, 14_42_52, 2], [77, 13_26_19, 34_78, 3_68, 10_95_86, 3_54_33, 2]]

											lowercase_     :					Dict													=	tokenizer.batch_encode_plus(__SCREAMING_SNAKE_CASE		)['''input_ids''']
											self.assertListEqual(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Tuple													=	tokenizer.batch_decode(__SCREAMING_SNAKE_CASE		)
											self.assertListEqual(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE=6		):


											"""simple docstring"""





											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
																							lowercase_     :					int													=	self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE    ,							**__SCREAMING_SNAKE_CASE		)
																							# tokenizer_r.pad_token = None # Hotfixing padding = None
																							# Simple input
																							lowercase_     :					Optional[int]													=	'''This is a simple input'''
																							lowercase_     :					List[str]													=	['''This is a simple input 1''', '''This is a simple input 2''']
																							lowercase_     :					List[str]													=	('''This is a simple input''', '''This is a pair''')
																							lowercase_     :					Union[str, Any]													=	[
																							    ('''This is a simple input 1''', '''This is a simple input 2'''),
																							    ('''This is a simple pair 1''', '''This is a simple pair 2'''),
																							]

																							# Simple input tests
																							try:
																													tokenizer_r.encode(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)
																													tokenizer_r.encode_plus(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)

																													tokenizer_r.batch_encode_plus(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)
																													tokenizer_r.encode(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)
																													tokenizer_r.batch_encode_plus(__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE		)
																							except ValueError:
																													self.fail('''Bloom Tokenizer should be able to deal with padding'''		)

																							lowercase_     :					Optional[Any]													=	None  # Hotfixing padding = None
																							self.assertRaises(__SCREAMING_SNAKE_CASE    ,							tokenizer_r.encode    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''		)

																							# Simple input
																							self.assertRaises(__SCREAMING_SNAKE_CASE    ,							tokenizer_r.encode_plus    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''		)

																							# Simple input
																							self.assertRaises(
																							    __SCREAMING_SNAKE_CASE    ,							tokenizer_r.batch_encode_plus    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''    ,							)

																							# Pair input
																							self.assertRaises(__SCREAMING_SNAKE_CASE    ,							tokenizer_r.encode    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''		)

																							# Pair input
																							self.assertRaises(__SCREAMING_SNAKE_CASE    ,							tokenizer_r.encode_plus    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''		)

																							# Pair input
																							self.assertRaises(
																							    __SCREAMING_SNAKE_CASE    ,							tokenizer_r.batch_encode_plus    ,							__SCREAMING_SNAKE_CASE    ,							max_length=__SCREAMING_SNAKE_CASE    ,							padding='''max_length'''    ,							)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					List[str]													=	self.get_rust_tokenizer()
											lowercase_     :					Tuple													=	load_dataset('''xnli'''    ,							'''all_languages'''    ,							split='''test'''    ,							streaming=__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Optional[int]													=	next(iter(__SCREAMING_SNAKE_CASE		)		)['''premise''']  # pick up one data
											lowercase_     :					List[Any]													=	list(sample_data.values()		)

											lowercase_     :					Tuple													=	list(map(tokenizer.encode    ,							__SCREAMING_SNAKE_CASE		)		)
											lowercase_     :					Any													=	[tokenizer.decode(__SCREAMING_SNAKE_CASE    ,							clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE		) for x in output_tokens]
											self.assertListEqual(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											self.assertGreaterEqual(len(self.tokenizer_class.pretrained_vocab_files_map		)    ,							1		)
											self.assertGreaterEqual(len(list(self.tokenizer_class.pretrained_vocab_files_map.values()		)[0]		)    ,							1		)



