





import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, 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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
	    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
	    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
	    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
	    LayoutLMvaConfig,
	    LayoutLMvaForQuestionAnswering,
	    LayoutLMvaForSequenceClassification,
	    LayoutLMvaForTokenClassification,
	    LayoutLMvaModel,
	)
	from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
	from PIL import Image

	from transformers import LayoutLMvaImageProcessor




class   UpperCamelCase_       :


							def __init__(							self    :Optional[Any]							,				__A    :Tuple							,				__A    :List[Any]=2							,				__A    :Tuple=3							,				__A    :Union[str, Any]=4							,				__A    :List[Any]=2							,				__A    :List[str]=7							,				__A    :str=True							,				__A    :List[Any]=True							,				__A    :str=True							,				__A    :Union[str, Any]=True							,				__A    :Dict=99							,				__A    :Union[str, Any]=36							,				__A    :Dict=3							,				__A    :int=4							,				__A    :Tuple=37							,				__A    :Union[str, Any]="gelu"							,				__A    :int=0.1							,				__A    :Optional[Any]=0.1							,				__A    :int=512							,				__A    :List[Any]=16							,				__A    :Any=2							,				__A    :Dict=0.0_2							,				__A    :List[Any]=6							,				__A    :Union[str, Any]=6							,				__A    :Tuple=3							,				__A    :Tuple=4							,				__A    :Optional[Any]=None							,				__A    :str=1000							,				)   ->   List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      parent
									SCREAMING_SNAKE_CASE__			=      batch_size
									SCREAMING_SNAKE_CASE__			=      num_channels
									SCREAMING_SNAKE_CASE__			=      image_size
									SCREAMING_SNAKE_CASE__			=      patch_size
									SCREAMING_SNAKE_CASE__			=      text_seq_length
									SCREAMING_SNAKE_CASE__			=      is_training
									SCREAMING_SNAKE_CASE__			=      use_input_mask
									SCREAMING_SNAKE_CASE__			=      use_token_type_ids
									SCREAMING_SNAKE_CASE__			=      use_labels
									SCREAMING_SNAKE_CASE__			=      vocab_size
									SCREAMING_SNAKE_CASE__			=      hidden_size
									SCREAMING_SNAKE_CASE__			=      num_hidden_layers
									SCREAMING_SNAKE_CASE__			=      num_attention_heads
									SCREAMING_SNAKE_CASE__			=      intermediate_size
									SCREAMING_SNAKE_CASE__			=      hidden_act
									SCREAMING_SNAKE_CASE__			=      hidden_dropout_prob
									SCREAMING_SNAKE_CASE__			=      attention_probs_dropout_prob
									SCREAMING_SNAKE_CASE__			=      max_position_embeddings
									SCREAMING_SNAKE_CASE__			=      type_vocab_size
									SCREAMING_SNAKE_CASE__			=      type_sequence_label_size
									SCREAMING_SNAKE_CASE__			=      initializer_range
									SCREAMING_SNAKE_CASE__			=      coordinate_size
									SCREAMING_SNAKE_CASE__			=      shape_size
									SCREAMING_SNAKE_CASE__			=      num_labels
									SCREAMING_SNAKE_CASE__			=      num_choices
									SCREAMING_SNAKE_CASE__			=      scope
									SCREAMING_SNAKE_CASE__			=      range_bbox

									# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
									SCREAMING_SNAKE_CASE__			=      text_seq_length
									SCREAMING_SNAKE_CASE__			=      (image_size // patch_size) ** 2 + 1
									SCREAMING_SNAKE_CASE__			=      self.text_seq_length + self.image_seq_length


							def      _snake_case  (							self    :str		)   ->   Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      ids_tensor([self.batch_size, self.text_seq_length]							,				self.vocab_size		)

									SCREAMING_SNAKE_CASE__			=      ids_tensor([self.batch_size, self.text_seq_length, 4]							,				self.range_bbox		)
									# Ensure that bbox is legal
									for i in range(bbox.shape[0]		):
											for j in range(bbox.shape[1]		):
													if bbox[i, j, 3] < bbox[i, j, 1]:
															SCREAMING_SNAKE_CASE__			=      bbox[i, j, 3]
															SCREAMING_SNAKE_CASE__			=      bbox[i, j, 1]
															SCREAMING_SNAKE_CASE__			=      t
													if bbox[i, j, 2] < bbox[i, j, 0]:
															SCREAMING_SNAKE_CASE__			=      bbox[i, j, 2]
															SCREAMING_SNAKE_CASE__			=      bbox[i, j, 0]
															SCREAMING_SNAKE_CASE__			=      t

									SCREAMING_SNAKE_CASE__			=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

									SCREAMING_SNAKE_CASE__			=      None
									if self.use_input_mask:
											SCREAMING_SNAKE_CASE__			=      random_attention_mask([self.batch_size, self.text_seq_length]		)

									SCREAMING_SNAKE_CASE__			=      None
									if self.use_token_type_ids:
											SCREAMING_SNAKE_CASE__			=      ids_tensor([self.batch_size, self.text_seq_length]							,				self.type_vocab_size		)

									SCREAMING_SNAKE_CASE__			=      None
									SCREAMING_SNAKE_CASE__			=      None
									if self.use_labels:
											SCREAMING_SNAKE_CASE__			=      ids_tensor([self.batch_size]							,				self.type_sequence_label_size		)
											SCREAMING_SNAKE_CASE__			=      ids_tensor([self.batch_size, self.text_seq_length]							,				self.num_labels		)

									SCREAMING_SNAKE_CASE__			=      LayoutLMvaConfig(
									    vocab_size=self.vocab_size							,				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							,				max_position_embeddings=self.max_position_embeddings							,				type_vocab_size=self.type_vocab_size							,				initializer_range=self.initializer_range							,				coordinate_size=self.coordinate_size							,				shape_size=self.shape_size							,				input_size=self.image_size							,				patch_size=self.patch_size							,				)

									return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels


							def      _snake_case  (							self    :Any							,				__A    :Optional[Any]							,				__A    :Optional[Any]							,				__A    :List[str]							,				__A    :List[str]							,				__A    :int							,				__A    :Optional[Any]							,				__A    :Tuple							,				__A    :Tuple		)   ->   Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      LayoutLMvaModel(config=__A		)
									model.to(__A		)
									model.eval()

									# text + image
									SCREAMING_SNAKE_CASE__			=      model(__A							,				pixel_values=__A		)
									SCREAMING_SNAKE_CASE__			=      model(
									    __A							,				bbox=__A							,				pixel_values=__A							,				attention_mask=__A							,				token_type_ids=__A		)
									SCREAMING_SNAKE_CASE__			=      model(__A							,				bbox=__A							,				pixel_values=__A							,				token_type_ids=__A		)
									SCREAMING_SNAKE_CASE__			=      model(__A							,				bbox=__A							,				pixel_values=__A		)

									self.parent.assertEqual(result.last_hidden_state.shape							,				(self.batch_size, self.seq_length, self.hidden_size)		)

									# text only
									SCREAMING_SNAKE_CASE__			=      model(__A		)
									self.parent.assertEqual(
									    result.last_hidden_state.shape							,				(self.batch_size, self.text_seq_length, self.hidden_size)		)

									# image only
									SCREAMING_SNAKE_CASE__			=      model(pixel_values=__A		)
									self.parent.assertEqual(
									    result.last_hidden_state.shape							,				(self.batch_size, self.image_seq_length, self.hidden_size)		)


							def      _snake_case  (							self    :List[Any]							,				__A    :List[Any]							,				__A    :Optional[Any]							,				__A    :Union[str, Any]							,				__A    :int							,				__A    :List[str]							,				__A    :Any							,				__A    :str							,				__A    :Dict		)   ->   List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.num_labels
									SCREAMING_SNAKE_CASE__			=      LayoutLMvaForSequenceClassification(__A		)
									model.to(__A		)
									model.eval()
									SCREAMING_SNAKE_CASE__			=      model(
									    __A							,				bbox=__A							,				pixel_values=__A							,				attention_mask=__A							,				token_type_ids=__A							,				labels=__A							,				)
									self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.num_labels)		)


							def      _snake_case  (							self    :List[Any]							,				__A    :int							,				__A    :List[Any]							,				__A    :Optional[int]							,				__A    :Dict							,				__A    :Optional[Any]							,				__A    :Union[str, Any]							,				__A    :List[str]							,				__A    :List[Any]		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.num_labels
									SCREAMING_SNAKE_CASE__			=      LayoutLMvaForTokenClassification(config=__A		)
									model.to(__A		)
									model.eval()
									SCREAMING_SNAKE_CASE__			=      model(
									    __A							,				bbox=__A							,				pixel_values=__A							,				attention_mask=__A							,				token_type_ids=__A							,				labels=__A							,				)
									self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.text_seq_length, self.num_labels)		)


							def      _snake_case  (							self    :Union[str, Any]							,				__A    :Tuple							,				__A    :Union[str, Any]							,				__A    :Tuple							,				__A    :Optional[Any]							,				__A    :List[Any]							,				__A    :Union[str, Any]							,				__A    :Optional[int]							,				__A    :int		)   ->   List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      LayoutLMvaForQuestionAnswering(config=__A		)
									model.to(__A		)
									model.eval()
									SCREAMING_SNAKE_CASE__			=      model(
									    __A							,				bbox=__A							,				pixel_values=__A							,				attention_mask=__A							,				token_type_ids=__A							,				start_positions=__A							,				end_positions=__A							,				)
									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      _snake_case  (							self    :Optional[int]		)   ->   Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.prepare_config_and_inputs()
									(
									    (
									    SCREAMING_SNAKE_CASE__
									)	,						(
									    SCREAMING_SNAKE_CASE__
									)	,						(
									    SCREAMING_SNAKE_CASE__
									)	,						(
									    SCREAMING_SNAKE_CASE__
									)	,						(
									    SCREAMING_SNAKE_CASE__
									)	,						(
									    SCREAMING_SNAKE_CASE__
									)	,						(
									    SCREAMING_SNAKE_CASE__
									)	,						(
									    SCREAMING_SNAKE_CASE__
									)	,						
									)			=      config_and_inputs
									SCREAMING_SNAKE_CASE__			=      {
									    """input_ids""": input_ids,
									    """bbox""": bbox,
									    """pixel_values""": pixel_values,
									    """token_type_ids""": token_type_ids,
									    """attention_mask""": input_mask,
									}
									return config, inputs_dict




@require_torch
class   UpperCamelCase_       (     UpperCamelCase__				,  UpperCamelCase__				,  unittest.TestCase    ):
							lowerCamelCase_           =					False
							lowerCamelCase_           =					False
							lowerCamelCase_           =					False

							lowerCamelCase_           =					(
							    (
							        LayoutLMvaModel,
							        LayoutLMvaForSequenceClassification,
							        LayoutLMvaForTokenClassification,
							        LayoutLMvaForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							lowerCamelCase_           =					(
							    {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
							    if is_torch_available()
							    else {}
							)


							def      _snake_case  (							self    :Any							,				__A    :str							,				__A    :Dict							,				__A    :Optional[int]							,				__A    :List[str]							,				__A    :Union[str, Any]		)   ->   Union[str, Any]:



									"""simple docstring"""



									return True


							def      _snake_case  (							self    :int		)   ->   Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      LayoutLMvaModelTester(self		)
									SCREAMING_SNAKE_CASE__			=      ConfigTester(self							,				config_class=__A							,				hidden_size=37		)


							def      _snake_case  (							self    :str							,				__A    :Any							,				__A    :Union[str, Any]							,				__A    :List[str]=False		)   ->   Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      copy.deepcopy(__A		)
									if model_class in get_values(__A		):
											SCREAMING_SNAKE_CASE__			=      {
											    k: v.unsqueeze(1		).expand(-1							,				self.model_tester.num_choices							,				-1		).contiguous()
											    if isinstance(__A							,				torch.Tensor		) and v.ndim > 1
											    else v
											    for k, v in inputs_dict.items()
											}
									if return_labels:
											if model_class in get_values(__A		):
													SCREAMING_SNAKE_CASE__			=      torch.ones(self.model_tester.batch_size							,				dtype=torch.long							,				device=__A		)
											elif model_class in get_values(__A		):
													SCREAMING_SNAKE_CASE__			=      torch.zeros(
													    self.model_tester.batch_size							,				dtype=torch.long							,				device=__A		)
													SCREAMING_SNAKE_CASE__			=      torch.zeros(
													    self.model_tester.batch_size							,				dtype=torch.long							,				device=__A		)
											elif model_class in [
											    *get_values(__A		),
											]:
													SCREAMING_SNAKE_CASE__			=      torch.zeros(
													    self.model_tester.batch_size							,				dtype=torch.long							,				device=__A		)
											elif model_class in [
											    *get_values(__A		),
											]:
													SCREAMING_SNAKE_CASE__			=      torch.zeros(
													    (self.model_tester.batch_size, self.model_tester.text_seq_length)							,				dtype=torch.long							,				device=__A							,				)

									return inputs_dict


							def      _snake_case  (							self    :str		)   ->   Optional[int]:



									"""simple docstring"""



									self.config_tester.run_common_tests()


							def      _snake_case  (							self    :Optional[int]		)   ->   int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__A		)


							def      _snake_case  (							self    :List[Any]		)   ->   Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
											SCREAMING_SNAKE_CASE__			=      type
											self.model_tester.create_and_check_model(*__A		)


							def      _snake_case  (							self    :Tuple		)   ->   int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*__A		)


							def      _snake_case  (							self    :Any		)   ->   List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*__A		)


							def      _snake_case  (							self    :Optional[Any]		)   ->   Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*__A		)


							@slow
							def      _snake_case  (							self    :Optional[int]		)   ->   Optional[int]:



									"""simple docstring"""



									for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE__			=      LayoutLMvaModel.from_pretrained(__A		)
											self.assertIsNotNone(__A		)






def 				SCREAMING_SNAKE_CASE__							(       ):
		SCREAMING_SNAKE_CASE__			=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
		return image




@require_torch
class   UpperCamelCase_       (     unittest.TestCase    ):


							@cached_property
							def      _snake_case  (							self    :str		)   ->   int:



									"""simple docstring"""



									return LayoutLMvaImageProcessor(apply_ocr=__A		) if is_vision_available() else None


							@slow
							def      _snake_case  (							self    :str		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      LayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base"""		).to(__A		)

									SCREAMING_SNAKE_CASE__			=      self.default_image_processor
									SCREAMING_SNAKE_CASE__			=      prepare_img()
									SCREAMING_SNAKE_CASE__			=      image_processor(images=__A							,				return_tensors="""pt"""		).pixel_values.to(__A		)

									SCREAMING_SNAKE_CASE__			=      torch.tensor([[1, 2]]		)
									SCREAMING_SNAKE_CASE__			=      torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]		).unsqueeze(0		)

									# forward pass
									SCREAMING_SNAKE_CASE__			=      model(
									    input_ids=input_ids.to(__A		)							,				bbox=bbox.to(__A		)							,				pixel_values=pixel_values.to(__A		)							,				)

									# verify the logits
									SCREAMING_SNAKE_CASE__			=      torch.Size((1, 199, 768)		)
									self.assertEqual(outputs.last_hidden_state.shape							,				__A		)

									SCREAMING_SNAKE_CASE__			=      torch.tensor(
									    [[-0.0_5_2_9, 0.3_6_1_8, 0.1_6_3_2], [-0.1_5_8_7, -0.1_6_6_7, -0.0_4_0_0], [-0.1_5_5_7, -0.1_6_7_1, -0.0_5_0_5]]		).to(__A		)

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






import json
import os
import unittest

from transformers import OpenAIGPTTokenizer, OpenAIGPTTokenizerFast
from transformers.models.openai.tokenization_openai import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_spacy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class   UpperCamelCase_       (     UpperCamelCase__				,  unittest.TestCase    ):
							lowerCamelCase_           =					OpenAIGPTTokenizer
							lowerCamelCase_           =					OpenAIGPTTokenizerFast
							lowerCamelCase_           =					True
							lowerCamelCase_           =					False


							def      _snake_case  (							self    :Optional[Any]		)   ->   Dict:



									"""simple docstring"""



									super().setUp()

									# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
									SCREAMING_SNAKE_CASE__			=      [
									    """l""",
									    """o""",
									    """w""",
									    """e""",
									    """r""",
									    """s""",
									    """t""",
									    """i""",
									    """d""",
									    """n""",
									    """w</w>""",
									    """r</w>""",
									    """t</w>""",
									    """lo""",
									    """low""",
									    """er</w>""",
									    """low</w>""",
									    """lowest</w>""",
									    """newer</w>""",
									    """wider</w>""",
									    """<unk>""",
									]
									SCREAMING_SNAKE_CASE__			=      dict(zip(__A							,				range(len(__A		)		)		)		)
									SCREAMING_SNAKE_CASE__			=      ["""#version: 0.2""", """l o""", """lo w""", """e r</w>""", """"""]

									SCREAMING_SNAKE_CASE__			=      os.path.join(self.tmpdirname							,				VOCAB_FILES_NAMES["""vocab_file"""]		)
									SCREAMING_SNAKE_CASE__			=      os.path.join(self.tmpdirname							,				VOCAB_FILES_NAMES["""merges_file"""]		)
									with open(self.vocab_file							,				"""w"""		) as fp:
											fp.write(json.dumps(__A		)		)
									with open(self.merges_file							,				"""w"""		) as fp:
											fp.write("""\n""".join(__A		)		)


							def      _snake_case  (							self    :Union[str, Any]							,				__A    :str		)   ->   List[Any]:



									"""simple docstring"""



									return "lower newer", "lower newer"


							def      _snake_case  (							self    :Optional[Any]		)   ->   Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      OpenAIGPTTokenizer(self.vocab_file							,				self.merges_file		)

									SCREAMING_SNAKE_CASE__			=      """lower"""
									SCREAMING_SNAKE_CASE__			=      ["""low""", """er</w>"""]
									SCREAMING_SNAKE_CASE__			=      tokenizer.tokenize(__A		)
									self.assertListEqual(__A							,				__A		)

									SCREAMING_SNAKE_CASE__			=      tokens + ["""<unk>"""]
									SCREAMING_SNAKE_CASE__			=      [14, 15, 20]
									self.assertListEqual(tokenizer.convert_tokens_to_ids(__A		)							,				__A		)


							def      _snake_case  (							self    :Optional[Any]							,				__A    :Optional[Any]=15		)   ->   Any:



									"""simple docstring"""



									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
													SCREAMING_SNAKE_CASE__			=      self.rust_tokenizer_class.from_pretrained(__A							,				**__A		)

													# Simple input
													SCREAMING_SNAKE_CASE__			=      """This is a simple input"""
													SCREAMING_SNAKE_CASE__			=      ["""This is a simple input 1""", """This is a simple input 2"""]
													SCREAMING_SNAKE_CASE__			=      ("""This is a simple input""", """This is a pair""")
													SCREAMING_SNAKE_CASE__			=      [
													    ("""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
													self.assertRaises(__A							,				tokenizer_r.encode							,				__A							,				max_length=__A							,				padding="""max_length"""		)

													# Simple input
													self.assertRaises(__A							,				tokenizer_r.encode_plus							,				__A							,				max_length=__A							,				padding="""max_length"""		)

													# Simple input
													self.assertRaises(
													    __A							,				tokenizer_r.batch_encode_plus							,				__A							,				max_length=__A							,				padding="""max_length"""							,				)

													# Pair input
													self.assertRaises(__A							,				tokenizer_r.encode							,				__A							,				max_length=__A							,				padding="""max_length"""		)

													# Pair input
													self.assertRaises(__A							,				tokenizer_r.encode_plus							,				__A							,				max_length=__A							,				padding="""max_length"""		)

													# Pair input
													self.assertRaises(
													    __A							,				tokenizer_r.batch_encode_plus							,				__A							,				max_length=__A							,				padding="""max_length"""							,				)


							def      _snake_case  (							self    :Dict		)   ->   List[Any]:



									"""simple docstring"""



									pass




@require_ftfy
@require_spacy
@require_tokenizers
class   UpperCamelCase_       (     UpperCamelCase__    ):
							pass