






import unittest

from transformers import FunnelConfig, FunnelTokenizer, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

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


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_PRETRAINING_MAPPING,
		    FunnelBaseModel,
		    FunnelForMaskedLM,
		    FunnelForMultipleChoice,
		    FunnelForPreTraining,
		    FunnelForQuestionAnswering,
		    FunnelForSequenceClassification,
		    FunnelForTokenClassification,
		    FunnelModel,
		)





class __lowerCamelCase			:





	"""simple docstring"""






	def __init__(							self	,   UpperCAmelCase	,   UpperCAmelCase=13	,   UpperCAmelCase=7	,   UpperCAmelCase=True	,   UpperCAmelCase=True	,   UpperCAmelCase=True	,   UpperCAmelCase=True	,   UpperCAmelCase=99	,   UpperCAmelCase=[1, 1, 2]	,   UpperCAmelCase=1	,   UpperCAmelCase=32	,   UpperCAmelCase=4	,   UpperCAmelCase=8	,   UpperCAmelCase=37	,   UpperCAmelCase="gelu_new"	,   UpperCAmelCase=0.1	,   UpperCAmelCase=0.1	,   UpperCAmelCase=0.0	,   UpperCAmelCase=512	,   UpperCAmelCase=3	,   UpperCAmelCase=0.02	,   UpperCAmelCase=3	,   UpperCAmelCase=4	,   UpperCAmelCase=None	,   UpperCAmelCase=False	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      parent
							_UpperCAmelCase     =      batch_size
							_UpperCAmelCase     =      seq_length
							_UpperCAmelCase     =      is_training
							_UpperCAmelCase     =      use_input_mask
							_UpperCAmelCase     =      use_token_type_ids
							_UpperCAmelCase     =      use_labels
							_UpperCAmelCase     =      vocab_size
							_UpperCAmelCase     =      block_sizes
							_UpperCAmelCase     =      num_decoder_layers
							_UpperCAmelCase     =      d_model
							_UpperCAmelCase     =      n_head
							_UpperCAmelCase     =      d_head
							_UpperCAmelCase     =      d_inner
							_UpperCAmelCase     =      hidden_act
							_UpperCAmelCase     =      hidden_dropout
							_UpperCAmelCase     =      attention_dropout
							_UpperCAmelCase     =      activation_dropout
							_UpperCAmelCase     =      max_position_embeddings
							_UpperCAmelCase     =      type_vocab_size
							_UpperCAmelCase     =      2
							_UpperCAmelCase     =      num_labels
							_UpperCAmelCase     =      num_choices
							_UpperCAmelCase     =      scope
							_UpperCAmelCase     =      initializer_std

							# Used in the tests to check the size of the first attention layer
							_UpperCAmelCase     =      n_head
							# Used in the tests to check the size of the first hidden state
							_UpperCAmelCase     =      self.d_model
							# Used in the tests to check the number of output hidden states/attentions
							_UpperCAmelCase     =      sum(self.block_sizes   ) + (0 if base else self.num_decoder_layers)
							# FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
							# the last hidden state of the first block (which is the first hidden state of the decoder).
							if not base:
													_UpperCAmelCase     =      self.num_hidden_layers + 2

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      ids_tensor([self.batch_size, self.seq_length]	,   self.vocab_size   )

							_UpperCAmelCase     =      None
							if self.use_input_mask:
													_UpperCAmelCase     =      ids_tensor([self.batch_size, self.seq_length]	,   vocab_size=2   )

							_UpperCAmelCase     =      None
							if self.use_token_type_ids:
													_UpperCAmelCase     =      ids_tensor([self.batch_size, self.seq_length]	,   self.type_vocab_size   )

							_UpperCAmelCase     =      None
							_UpperCAmelCase     =      None
							_UpperCAmelCase     =      None
							if self.use_labels:
													_UpperCAmelCase     =      ids_tensor([self.batch_size]	,   self.type_sequence_label_size   )
													_UpperCAmelCase     =      ids_tensor([self.batch_size, self.seq_length]	,   self.num_labels   )
													_UpperCAmelCase     =      ids_tensor([self.batch_size]	,   self.num_choices   )
													_UpperCAmelCase     =      ids_tensor([self.batch_size, self.seq_length]	,   1   )

							_UpperCAmelCase     =      self.get_config()

							return (
							    config,
							    input_ids,
							    token_type_ids,
							    input_mask,
							    sequence_labels,
							    token_labels,
							    choice_labels,
							    fake_token_labels,
							)

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							return FunnelConfig(
							    vocab_size=self.vocab_size	,   block_sizes=self.block_sizes	,   num_decoder_layers=self.num_decoder_layers	,   d_model=self.d_model	,   n_head=self.n_head	,   d_head=self.d_head	,   d_inner=self.d_inner	,   hidden_act=self.hidden_act	,   hidden_dropout=self.hidden_dropout	,   attention_dropout=self.attention_dropout	,   activation_dropout=self.activation_dropout	,   max_position_embeddings=self.max_position_embeddings	,   type_vocab_size=self.type_vocab_size	,   initializer_std=self.initializer_std	,   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      FunnelModel(config=lowercase__   )
							model.to(lowercase__   )
							model.eval()
							_UpperCAmelCase     =      model(lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__   )
							_UpperCAmelCase     =      model(lowercase__	,   token_type_ids=lowercase__   )
							_UpperCAmelCase     =      model(lowercase__   )
							self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, self.seq_length, self.d_model)   )

							_UpperCAmelCase     =      False
							_UpperCAmelCase     =      model(lowercase__   )
							self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, self.seq_length, self.d_model)   )

							_UpperCAmelCase     =      False
							_UpperCAmelCase     =      model(lowercase__   )
							self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, self.seq_length, self.d_model)   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      FunnelBaseModel(config=lowercase__   )
							model.to(lowercase__   )
							model.eval()
							_UpperCAmelCase     =      model(lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__   )
							_UpperCAmelCase     =      model(lowercase__	,   token_type_ids=lowercase__   )
							_UpperCAmelCase     =      model(lowercase__   )
							self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, 2, self.d_model)   )

							_UpperCAmelCase     =      False
							_UpperCAmelCase     =      model(lowercase__   )
							self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, 3, self.d_model)   )

							_UpperCAmelCase     =      False
							_UpperCAmelCase     =      model(lowercase__   )
							self.parent.assertEqual(result.last_hidden_state.shape	,   (self.batch_size, 2, self.d_model)   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.num_labels
							_UpperCAmelCase     =      FunnelForPreTraining(config=lowercase__   )
							model.to(lowercase__   )
							model.eval()
							_UpperCAmelCase     =      model(lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__	,   labels=lowercase__   )
							self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.seq_length)   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      FunnelForMaskedLM(config=lowercase__   )
							model.to(lowercase__   )
							model.eval()
							_UpperCAmelCase     =      model(lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__	,   labels=lowercase__   )
							self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.seq_length, self.vocab_size)   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.num_labels
							_UpperCAmelCase     =      FunnelForSequenceClassification(lowercase__   )
							model.to(lowercase__   )
							model.eval()
							_UpperCAmelCase     =      model(lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__	,   labels=lowercase__   )
							self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_labels)   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.num_choices
							_UpperCAmelCase     =      FunnelForMultipleChoice(config=lowercase__   )
							model.to(lowercase__   )
							model.eval()
							_UpperCAmelCase     =      input_ids.unsqueeze(1   ).expand(-1	,   self.num_choices	,   -1   ).contiguous()
							_UpperCAmelCase     =      token_type_ids.unsqueeze(1   ).expand(-1	,   self.num_choices	,   -1   ).contiguous()
							_UpperCAmelCase     =      input_mask.unsqueeze(1   ).expand(-1	,   self.num_choices	,   -1   ).contiguous()
							_UpperCAmelCase     =      model(
							    lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__	,   labels=lowercase__	,   )
							self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_choices)   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.num_labels
							_UpperCAmelCase     =      FunnelForTokenClassification(config=lowercase__   )
							model.to(lowercase__   )
							model.eval()
							_UpperCAmelCase     =      model(lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__	,   labels=lowercase__   )
							self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.seq_length, self.num_labels)   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase	,   ):
							"""simple docstring"""







							_UpperCAmelCase     =      FunnelForQuestionAnswering(config=lowercase__   )
							model.to(lowercase__   )
							model.eval()
							_UpperCAmelCase     =      model(
							    lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__	,   start_positions=lowercase__	,   end_positions=lowercase__	,   )
							self.parent.assertEqual(result.start_logits.shape	,   (self.batch_size, self.seq_length)   )
							self.parent.assertEqual(result.end_logits.shape	,   (self.batch_size, self.seq_length)   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.prepare_config_and_inputs()
							(
							    (
							    _UpperCAmelCase   
							) ,			(
							    _UpperCAmelCase   
							) ,			(
							    _UpperCAmelCase   
							) ,			(
							    _UpperCAmelCase   
							) ,			(
							    _UpperCAmelCase   
							) ,			(
							    _UpperCAmelCase   
							) ,			(
							    _UpperCAmelCase   
							) ,			(
							    _UpperCAmelCase   
							) ,			   
							)     =      config_and_inputs
							_UpperCAmelCase     =      {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
							return config, inputs_dict





@require_torch
class __lowerCamelCase			(				snake_case__					,	snake_case__					,	unittest.TestCase):





	"""simple docstring"""






	UpperCamelCase__								=				False
	UpperCamelCase__								=				False
	UpperCamelCase__								=				(
	    (
	        FunnelModel,
	        FunnelForMaskedLM,
	        FunnelForPreTraining,
	        FunnelForQuestionAnswering,
	        FunnelForTokenClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	UpperCamelCase__								=				(
	    {
	        "feature-extraction": (FunnelBaseModel, FunnelModel),
	        "fill-mask": FunnelForMaskedLM,
	        "question-answering": FunnelForQuestionAnswering,
	        "text-classification": FunnelForSequenceClassification,
	        "token-classification": FunnelForTokenClassification,
	        "zero-shot": FunnelForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)

	def 	UpperCamelCase   (							self	,   UpperCAmelCase	,   UpperCAmelCase	,   UpperCAmelCase=False   ):
							"""simple docstring"""







							_UpperCAmelCase     =      super()._prepare_for_class(lowercase__	,   lowercase__	,   return_labels=lowercase__   )

							if return_labels:
													if model_class in get_values(lowercase__   ):
																			_UpperCAmelCase     =      torch.zeros(
																			    (self.model_tester.batch_size, self.model_tester.seq_length)	,   dtype=torch.long	,   device=lowercase__   )
							return inputs_dict

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      FunnelModelTester(self   )
							_UpperCAmelCase     =      ConfigTester(self	,   config_class=lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							self.config_tester.run_common_tests()

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*lowercase__   )

	def 	UpperCamelCase   (							self	,   UpperCAmelCase   ):
							"""simple docstring"""







							if hasattr(lowercase__	,   'weight'   ) and module.weight is not None:
													module.weight.data.fill_(3   )
							if hasattr(lowercase__	,   'bias'   ) and module.bias is not None:
													module.bias.data.fill_(3   )

							for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
													if hasattr(lowercase__	,   lowercase__   ) and getattr(lowercase__	,   lowercase__   ) is not None:
																			_UpperCAmelCase     =      getattr(lowercase__	,   lowercase__   )
																			weight.data.fill_(3   )





@require_torch
class __lowerCamelCase			(				snake_case__					,	unittest.TestCase):





	"""simple docstring"""






	UpperCamelCase__								=				False
	UpperCamelCase__								=				False
	UpperCamelCase__								=				(
	    (FunnelBaseModel, FunnelForMultipleChoice, FunnelForSequenceClassification) if is_torch_available() else ()
	)

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      FunnelModelTester(self	,   base=lowercase__   )
							_UpperCAmelCase     =      ConfigTester(self	,   config_class=lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							self.config_tester.run_common_tests()

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_base_model(*lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*lowercase__   )

	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase ,			_UpperCAmelCase     =      self.model_tester.prepare_config_and_inputs_for_common()
							_UpperCAmelCase     =      True

							for model_class in self.all_model_classes:
													if model_class.__name__ == "FunnelBaseModel":
																			continue
													_UpperCAmelCase     =      model_class(lowercase__   )
													model.to(lowercase__   )
													model.train()
													_UpperCAmelCase     =      self._prepare_for_class(lowercase__	,   lowercase__	,   return_labels=lowercase__   )
													_UpperCAmelCase     =      model(**lowercase__   ).loss
													loss.backward()

	def 	UpperCamelCase   (							self	,   UpperCAmelCase   ):
							"""simple docstring"""







							if hasattr(lowercase__	,   'weight'   ) and module.weight is not None:
													module.weight.data.fill_(3   )
							if hasattr(lowercase__	,   'bias'   ) and module.bias is not None:
													module.bias.data.fill_(3   )

							for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
													if hasattr(lowercase__	,   lowercase__   ) and getattr(lowercase__	,   lowercase__   ) is not None:
																			_UpperCAmelCase     =      getattr(lowercase__	,   lowercase__   )
																			weight.data.fill_(3   )





@require_torch
@require_sentencepiece
@require_tokenizers
class __lowerCamelCase			(				unittest.TestCase):





	"""simple docstring"""






	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      13
							_UpperCAmelCase     =      7
							_UpperCAmelCase     =      torch.arange(0	,   batch_size * sequence_length   ).long().reshape(lowercase__	,   lowercase__   )
							_UpperCAmelCase     =      [0, 1, 2, 3, 4, 5, 6, 4, 1, 3, 5, 0, 1]
							_UpperCAmelCase     =      torch.tensor([[2] + [0] * a + [1] * (sequence_length - a - 1) for a in lengths]   )

							_UpperCAmelCase     =      FunnelModel.from_pretrained('sgugger/funnel-random-tiny'   )
							_UpperCAmelCase     =      model(lowercase__	,   token_type_ids=lowercase__   )[0].abs()

							_UpperCAmelCase     =      torch.tensor(2344.8352   )
							_UpperCAmelCase     =      torch.tensor(0.80_52   )
							self.assertTrue(torch.allclose(output.sum()	,   lowercase__	,   atol=1e-4   )   )
							self.assertTrue(torch.allclose(output.mean()	,   lowercase__	,   atol=1e-4   )   )

							_UpperCAmelCase     =      torch.tensor([[1] * 7, [1] * 4 + [0] * 3] * 6 + [[0, 1, 1, 0, 0, 1, 1]]   )
							_UpperCAmelCase     =      model(lowercase__	,   attention_mask=lowercase__	,   token_type_ids=lowercase__   )[0].abs()

							_UpperCAmelCase     =      torch.tensor(2343.8425   )
							_UpperCAmelCase     =      torch.tensor(0.80_49   )
							self.assertTrue(torch.allclose(output.sum()	,   lowercase__	,   atol=1e-4   )   )
							self.assertTrue(torch.allclose(output.mean()	,   lowercase__	,   atol=1e-4   )   )

	@slow
	def 	UpperCamelCase   (							self   ):
							"""simple docstring"""







							_UpperCAmelCase     =      FunnelTokenizer.from_pretrained('huggingface/funnel-small'   )
							_UpperCAmelCase     =      FunnelModel.from_pretrained('huggingface/funnel-small'   )
							_UpperCAmelCase     =      tokenizer('Hello! I am the Funnel Transformer model.'	,   return_tensors='pt'   )
							_UpperCAmelCase     =      model(**lowercase__   )[0]

							_UpperCAmelCase     =      torch.tensor(2_35.72_46   )
							_UpperCAmelCase     =      torch.tensor(0.02_56   )
							self.assertTrue(torch.allclose(output.sum()	,   lowercase__	,   atol=1e-4   )   )
							self.assertTrue(torch.allclose(output.mean()	,   lowercase__	,   atol=1e-4   )   )








from ..utils import DummyObject, requires_backends





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )





class __lowerCamelCase			(				metaclass=snake_case__):





	"""simple docstring"""






	UpperCamelCase__								=				["tokenizers"]

	def __init__(							self	,   *UpperCAmelCase	,   **UpperCAmelCase   ):
							"""simple docstring"""







							requires_backends(self	,   ['tokenizers']   )
