



import argparse
import collections
import os
import re
import tempfile

import pandas as pd
from datasets import Dataset
from huggingface_hub import hf_hub_download, upload_folder

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/update_metadata.py
_snake_case				=					'src/transformers'


# This is to make sure the transformers module imported is the one in the repo.
_snake_case				=					direct_transformers_import(TRANSFORMERS_PATH)


# Regexes that match TF/Flax/PT model names.
_snake_case				=					re.compile(r'TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
_snake_case				=					re.compile(r'Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
# Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes.
_snake_case				=					re.compile(r'(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')


# Fill this with tuples (pipeline_tag, model_mapping, auto_model)
_snake_case				=					[
    ('pretraining', 'MODEL_FOR_PRETRAINING_MAPPING_NAMES', 'AutoModelForPreTraining'),
    ('feature-extraction', 'MODEL_MAPPING_NAMES', 'AutoModel'),
    ('audio-classification', 'MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES', 'AutoModelForAudioClassification'),
    ('text-generation', 'MODEL_FOR_CAUSAL_LM_MAPPING_NAMES', 'AutoModelForCausalLM'),
    ('automatic-speech-recognition', 'MODEL_FOR_CTC_MAPPING_NAMES', 'AutoModelForCTC'),
    ('image-classification', 'MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES', 'AutoModelForImageClassification'),
    ('image-segmentation', 'MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES', 'AutoModelForImageSegmentation'),
    ('fill-mask', 'MODEL_FOR_MASKED_LM_MAPPING_NAMES', 'AutoModelForMaskedLM'),
    ('object-detection', 'MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMES', 'AutoModelForObjectDetection'),
    (
        'zero-shot-object-detection',
        'MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING_NAMES',
        'AutoModelForZeroShotObjectDetection',
    ),
    ('question-answering', 'MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES', 'AutoModelForQuestionAnswering'),
    ('text2text-generation', 'MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES', 'AutoModelForSeq2SeqLM'),
    ('text-classification', 'MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES', 'AutoModelForSequenceClassification'),
    ('automatic-speech-recognition', 'MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES', 'AutoModelForSpeechSeq2Seq'),
    (
        'table-question-answering',
        'MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMES',
        'AutoModelForTableQuestionAnswering',
    ),
    ('token-classification', 'MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES', 'AutoModelForTokenClassification'),
    ('multiple-choice', 'MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES', 'AutoModelForMultipleChoice'),
    (
        'next-sentence-prediction',
        'MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES',
        'AutoModelForNextSentencePrediction',
    ),
    (
        'audio-frame-classification',
        'MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING_NAMES',
        'AutoModelForAudioFrameClassification',
    ),
    ('audio-xvector', 'MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES', 'AutoModelForAudioXVector'),
    (
        'document-question-answering',
        'MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES',
        'AutoModelForDocumentQuestionAnswering',
    ),
    (
        'visual-question-answering',
        'MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMES',
        'AutoModelForVisualQuestionAnswering',
    ),
    ('image-to-text', 'MODEL_FOR_FOR_VISION_2_SEQ_MAPPING_NAMES', 'AutoModelForVision2Seq'),
    (
        'zero-shot-image-classification',
        'MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING_NAMES',
        'AutoModelForZeroShotImageClassification',
    ),
    ('depth-estimation', 'MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES', 'AutoModelForDepthEstimation'),
    ('video-classification', 'MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES', 'AutoModelForVideoClassification'),
    ('mask-generation', 'MODEL_FOR_MASK_GENERATION_MAPPING_NAMES', 'AutoModelForMaskGeneration'),
]
def     _a							(     __lowercase		)     ->						int:

							"""simple docstring"""





							__UpperCamelCase          =  re.finditer('.+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)'				, __lowercase		)
							return [m.group(0		) for m in matches]
def     _a							(     )     ->						Union[str, Any]:

							"""simple docstring"""





							__UpperCamelCase          =  transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
							__UpperCamelCase          =  {
							    config.replace('Config'				, ''		): model_type for model_type, config in config_maping_names.items()
							}

							# Dictionaries flagging if each model prefix has a backend in PT/TF/Flax.
							__UpperCamelCase          =  collections.defaultdict(__lowercase		)
							__UpperCamelCase          =  collections.defaultdict(__lowercase		)
							__UpperCamelCase          =  collections.defaultdict(__lowercase		)

							# Let's lookup through all transformers object (once) and find if models are supported by a given backend.
							for attr_name in dir(__lowercase		):
														__UpperCamelCase          =  None
														if _re_tf_models.match(__lowercase		) is not None:
																					__UpperCamelCase          =  tf_models
																					__UpperCamelCase          =  _re_tf_models.match(__lowercase		).groups()[0]
														elif _re_flax_models.match(__lowercase		) is not None:
																					__UpperCamelCase          =  flax_models
																					__UpperCamelCase          =  _re_flax_models.match(__lowercase		).groups()[0]
														elif _re_pt_models.match(__lowercase		) is not None:
																					__UpperCamelCase          =  pt_models
																					__UpperCamelCase          =  _re_pt_models.match(__lowercase		).groups()[0]

														if lookup_dict is not None:
																					while len(__lowercase		) > 0:
																												if attr_name in model_prefix_to_model_type:
																																			__UpperCamelCase          =  True
																																			break
																												# Try again after removing the last word in the name
																												__UpperCamelCase          =  "".join(camel_case_split(__lowercase		)[:-1]		)

							__UpperCamelCase          =  set(list(pt_models.keys()		) + list(tf_models.keys()		) + list(flax_models.keys()		)		)
							__UpperCamelCase          =  list(__lowercase		)
							all_models.sort()

							__UpperCamelCase          =  {"model_type": all_models}
							__UpperCamelCase          =  [pt_models[t] for t in all_models]
							__UpperCamelCase          =  [tf_models[t] for t in all_models]
							__UpperCamelCase          =  [flax_models[t] for t in all_models]

							# Now let's use the auto-mapping names to make sure
							__UpperCamelCase          =  {}
							for t in all_models:
														if t in transformers_module.models.auto.processing_auto.PROCESSOR_MAPPING_NAMES:
																					__UpperCamelCase          =  "AutoProcessor"
														elif t in transformers_module.models.auto.tokenization_auto.TOKENIZER_MAPPING_NAMES:
																					__UpperCamelCase          =  "AutoTokenizer"
														elif t in transformers_module.models.auto.feature_extraction_auto.FEATURE_EXTRACTOR_MAPPING_NAMES:
																					__UpperCamelCase          =  "AutoFeatureExtractor"
														else:
																					# Default to AutoTokenizer if a model has nothing, for backward compatibility.
																					__UpperCamelCase          =  "AutoTokenizer"

							__UpperCamelCase          =  [processors[t] for t in all_models]

							return pd.DataFrame(__lowercase		)
def     _a							(     __lowercase		)     ->						Any:

							"""simple docstring"""





							__UpperCamelCase          =  [
							    transformers_module.models.auto.modeling_auto,
							    transformers_module.models.auto.modeling_tf_auto,
							    transformers_module.models.auto.modeling_flax_auto,
							]
							for pipeline_tag, model_mapping, auto_class in PIPELINE_TAGS_AND_AUTO_MODELS:
														__UpperCamelCase          =  [model_mapping, F"""TF_{model_mapping}""", F"""FLAX_{model_mapping}"""]
														__UpperCamelCase          =  [auto_class, F"""TF_{auto_class}""", F"""Flax_{auto_class}"""]
														# Loop through all three frameworks
														for module, cls, mapping in zip(__lowercase				, __lowercase				, __lowercase		):
																					# The type of pipeline may not exist in this framework
																					if not hasattr(__lowercase				, __lowercase		):
																												continue
																					# First extract all model_names
																					__UpperCamelCase          =  []
																					for name in getattr(__lowercase				, __lowercase		).values():
																												if isinstance(__lowercase				, __lowercase		):
																																			model_names.append(__lowercase		)
																												else:
																																			model_names.extend(list(__lowercase		)		)

            # Add pipeline tag and auto model class for those models
																					table.update({model_name: (pipeline_tag, cls) for model_name in model_names}		)

							return table
def     _a							(     __lowercase				, __lowercase		)     ->						Any:

							"""simple docstring"""





							__UpperCamelCase          =  get_frameworks_table()
							__UpperCamelCase          =  Dataset.from_pandas(__lowercase		)

							__UpperCamelCase          =  hf_hub_download(
							    'huggingface/transformers-metadata'				, 'pipeline_tags.json'				, repo_type='dataset'				, token=__lowercase		)
							__UpperCamelCase          =  Dataset.from_json(__lowercase		)
							__UpperCamelCase          =  {
							    tags_dataset[i]["model_class"]: (tags_dataset[i]["pipeline_tag"], tags_dataset[i]["auto_class"])
							    for i in range(len(__lowercase		)		)
							}
							__UpperCamelCase          =  update_pipeline_and_auto_class_table(__lowercase		)

							# Sort the model classes to avoid some nondeterministic updates to create false update commits.
							__UpperCamelCase          =  sorted(table.keys()		)
							__UpperCamelCase          =  pd.DataFrame(
							    {
							        'model_class': model_classes,
							        'pipeline_tag': [table[m][0] for m in model_classes],
							        'auto_class': [table[m][1] for m in model_classes],
							    }		)
							__UpperCamelCase          =  Dataset.from_pandas(__lowercase		)

							with tempfile.TemporaryDirectory() as tmp_dir:
														frameworks_dataset.to_json(os.path.join(__lowercase				, 'frameworks.json'		)		)
														tags_dataset.to_json(os.path.join(__lowercase				, 'pipeline_tags.json'		)		)

														if commit_sha is not None:
																					__UpperCamelCase          =  (
																					    F"""Update with commit {commit_sha}\n\nSee: """
																					    F"""https://github.com/huggingface/transformers/commit/{commit_sha}"""
																					)
														else:
																					__UpperCamelCase          =  "Update"

														upload_folder(
														    repo_id='huggingface/transformers-metadata'				, folder_path=__lowercase				, repo_type='dataset'				, token=__lowercase				, commit_message=__lowercase				, )
def     _a							(     )     ->						Union[str, Any]:

							"""simple docstring"""





							__UpperCamelCase          =  {tag: cls for tag, _, cls in PIPELINE_TAGS_AND_AUTO_MODELS}
							__UpperCamelCase          =  transformers_module.pipelines.SUPPORTED_TASKS
							__UpperCamelCase          =  []
							for key in pipeline_tasks:
														if key not in in_table:
																					__UpperCamelCase          =  pipeline_tasks[key]["pt"]
																					if isinstance(__lowercase				, (list, tuple)		):
																												__UpperCamelCase          =  model[0]
																					__UpperCamelCase          =  model.__name__
																					if model not in in_table.values():
																												missing.append(__lowercase		)

							if len(__lowercase		) > 0:
														__UpperCamelCase          =  ", ".join(__lowercase		)
														raise ValueError(
														    'The following pipeline tags are not present in the `PIPELINE_TAGS_AND_AUTO_MODELS` constant inside '
														    F"""`utils/update_metadata.py`: {msg}. Please add them!"""		)


if __name__ == "__main__":
			_snake_case				=					argparse.ArgumentParser()
			parser.add_argument('--token', type=str, help='The token to use to push to the transformers-metadata dataset.')
			parser.add_argument('--commit_sha', type=str, help='The sha of the commit going with this update.')
			parser.add_argument('--check-only', action='store_true', help='Activate to just check all pipelines are present.')
			_snake_case				=					parser.parse_args()

			if args.check_only:
						check_pipeline_tags()
			else:
						update_metadata(args.token, args.commit_sha)







'''simple docstring'''


import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          XLMForMultipleChoice,
          XLMForQuestionAnswering,
          XLMForQuestionAnsweringSimple,
          XLMForSequenceClassification,
          XLMForTokenClassification,
          XLMModel,
          XLMWithLMHeadModel,
      )
      from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST







class 							__magic_name__	:

     """simple docstring"""






     def __init__(   self			,     lowerCamelCase			,     lowerCamelCase=13			,     lowerCamelCase=7			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=False			,     lowerCamelCase=False			,     lowerCamelCase=False			,     lowerCamelCase=2			,     lowerCamelCase=99			,     lowerCamelCase=0			,     lowerCamelCase=32			,     lowerCamelCase=5			,     lowerCamelCase=4			,     lowerCamelCase=0.1			,     lowerCamelCase=0.1			,     lowerCamelCase=512			,     lowerCamelCase=2			,     lowerCamelCase=0.02			,     lowerCamelCase=2			,     lowerCamelCase=4			,     lowerCamelCase="last"			,     lowerCamelCase=True			,     lowerCamelCase=None			,     lowerCamelCase=0			,     ):


          '''simple docstring'''





          __A	:       Tuple      =							parent
          __A	:       Optional[Any]      =							batch_size
          __A	:       int      =							seq_length
          __A	:       int      =							is_training
          __A	:       List[str]      =							use_input_lengths
          __A	:       Optional[Any]      =							use_token_type_ids
          __A	:       Any      =							use_labels
          __A	:       Dict      =							gelu_activation
          __A	:       List[str]      =							sinusoidal_embeddings
          __A	:       List[Any]      =							causal
          __A	:       Optional[int]      =							asm
          __A	:       List[Any]      =							n_langs
          __A	:       List[str]      =							vocab_size
          __A	:       Any      =							n_special
          __A	:       Optional[int]      =							hidden_size
          __A	:       Optional[Any]      =							num_hidden_layers
          __A	:       Tuple      =							num_attention_heads
          __A	:       List[str]      =							hidden_dropout_prob
          __A	:       Any      =							attention_probs_dropout_prob
          __A	:       Dict      =							max_position_embeddings
          __A	:       Optional[int]      =							type_sequence_label_size
          __A	:       Tuple      =							initializer_range
          __A	:       List[Any]      =							num_labels
          __A	:       List[Any]      =							num_choices
          __A	:       Any      =							summary_type
          __A	:       List[str]      =							use_proj
          __A	:       List[Any]      =							scope
          __A	:       str      =							bos_token_id


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size		)
          __A	:       int      =							random_attention_mask([self.batch_size, self.seq_length]		)

          __A	:       Union[str, Any]      =							None
          if self.use_input_lengths:
               __A	:       int      =							(
                   ids_tensor([self.batch_size]			,     vocab_size=2		) + self.seq_length - 2
               )  # small variation of seq_length

          __A	:       Any      =							None
          if self.use_token_type_ids:
               __A	:       Optional[int]      =							ids_tensor([self.batch_size, self.seq_length]			,     self.n_langs		)

          __A	:       int      =							None
          __A	:       Any      =							None
          __A	:       Tuple      =							None
          if self.use_labels:
               __A	:       List[Any]      =							ids_tensor([self.batch_size]			,     self.type_sequence_label_size		)
               __A	:       Optional[Any]      =							ids_tensor([self.batch_size, self.seq_length]			,     self.num_labels		)
               __A	:       int      =							ids_tensor([self.batch_size]			,     2		).float()
               __A	:       List[str]      =							ids_tensor([self.batch_size]			,     self.num_choices		)

          __A	:       List[Any]      =							self.get_config()

          return (
              config,
              input_ids,
              token_type_ids,
              input_lengths,
              sequence_labels,
              token_labels,
              is_impossible_labels,
              choice_labels,
              input_mask,
          )


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          return XLMConfig(
              vocab_size=self.vocab_size			,     n_special=self.n_special			,     emb_dim=self.hidden_size			,     n_layers=self.num_hidden_layers			,     n_heads=self.num_attention_heads			,     dropout=self.hidden_dropout_prob			,     attention_dropout=self.attention_probs_dropout_prob			,     gelu_activation=self.gelu_activation			,     sinusoidal_embeddings=self.sinusoidal_embeddings			,     asm=self.asm			,     causal=self.causal			,     n_langs=self.n_langs			,     max_position_embeddings=self.max_position_embeddings			,     initializer_range=self.initializer_range			,     summary_type=self.summary_type			,     use_proj=self.use_proj			,     num_labels=self.num_labels			,     bos_token_id=self.bos_token_id			,     )


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Tuple      =							XLMModel(config=lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()
          __A	:       Tuple      =							model(lowerCamelCase			,     lengths=lowerCamelCase			,     langs=lowerCamelCase		)
          __A	:       Dict      =							model(lowerCamelCase			,     langs=lowerCamelCase		)
          __A	:       List[Any]      =							model(lowerCamelCase		)
          self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							XLMWithLMHeadModel(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       List[str]      =							model(lowerCamelCase			,     token_type_ids=lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.loss.shape			,     ()		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							XLMForQuestionAnsweringSimple(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       int      =							model(lowerCamelCase		)

          __A	:       List[str]      =							model(lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase		)
          __A	:       List[Any]      =							outputs
          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 lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Optional[Any]      =							XLMForQuestionAnswering(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase		)

          __A	:       Optional[int]      =							model(
              lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase			,     cls_index=lowerCamelCase			,     is_impossible=lowerCamelCase			,     p_mask=lowerCamelCase			,     )

          __A	:       Any      =							model(
              lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase			,     cls_index=lowerCamelCase			,     is_impossible=lowerCamelCase			,     )

          ((__A)  ,)	:       List[str]      =							result_with_labels.to_tuple()

          __A	:       int      =							model(lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase		)

          ((__A)  ,)	:       List[Any]      =							result_with_labels.to_tuple()

          self.parent.assertEqual(result_with_labels.loss.shape			,     ()		)
          self.parent.assertEqual(result.start_top_log_probs.shape			,     (self.batch_size, model.config.start_n_top)		)
          self.parent.assertEqual(result.start_top_index.shape			,     (self.batch_size, model.config.start_n_top)		)
          self.parent.assertEqual(
              result.end_top_log_probs.shape			,     (self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
          self.parent.assertEqual(
              result.end_top_index.shape			,     (self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
          self.parent.assertEqual(result.cls_logits.shape			,     (self.batch_size,)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Optional[int]      =							XLMForSequenceClassification(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase		)
          __A	:       Optional[int]      =							model(lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.loss.shape			,     ()		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.type_sequence_label_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							self.num_labels
          __A	:       int      =							XLMForTokenClassification(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase			,     attention_mask=lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.num_labels)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Union[str, Any]      =							self.num_choices
          __A	:       Union[str, Any]      =							XLMForMultipleChoice(config=lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()
          __A	:       Union[str, Any]      =							input_ids.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Optional[int]      =							token_type_ids.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Tuple      =							input_mask.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Any      =							model(
              lowerCamelCase			,     attention_mask=lowerCamelCase			,     token_type_ids=lowerCamelCase			,     labels=lowerCamelCase			,     )
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_choices)		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       List[Any]      =							self.prepare_config_and_inputs()
          (
              (
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,
          )	:       str      =							config_and_inputs
          __A	:       int      =							{"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
          return config, inputs_dict







@require_torch
class 							__magic_name__	(       lowerCAmelCase    ,		lowerCAmelCase    ,		lowerCAmelCase    ,		unittest.TestCase ):

     """simple docstring"""






     lowerCamelCase__       						=				(
         (
             XLMModel,
             XLMWithLMHeadModel,
             XLMForQuestionAnswering,
             XLMForSequenceClassification,
             XLMForQuestionAnsweringSimple,
             XLMForTokenClassification,
             XLMForMultipleChoice,
         )
         if is_torch_available()
         else ()
     )
     lowerCamelCase__       						=				(
         (XLMWithLMHeadModel,) if is_torch_available() else ()
     )  # TODO (PVP): Check other models whether language generation is also applicable
     lowerCamelCase__       						=				(
         {
             'feature-extraction': XLMModel,
             'fill-mask': XLMWithLMHeadModel,
             'question-answering': XLMForQuestionAnsweringSimple,
             'text-classification': XLMForSequenceClassification,
             'text-generation': XLMWithLMHeadModel,
             'token-classification': XLMForTokenClassification,
             'zero-shot': XLMForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase		):


          '''simple docstring'''





          if (
              pipeline_test_casse_name == "QAPipelineTests"
              and tokenizer_name is not None
              and not tokenizer_name.endswith("Fast"		)
          ):
               # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
               # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
               # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
               return True

          return False


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False		):


          '''simple docstring'''





          __A	:       Optional[Any]      =							super()._prepare_for_class(lowerCamelCase			,     lowerCamelCase			,     return_labels=lowerCamelCase		)

          if return_labels:
               if model_class.__name__ == "XLMForQuestionAnswering":
                    __A	:       List[Any]      =							torch.zeros(
                        self.model_tester.batch_size			,     dtype=torch.long			,     device=lowerCamelCase		)
                    __A	:       Tuple      =							torch.zeros(
                        self.model_tester.batch_size			,     dtype=torch.long			,     device=lowerCamelCase		)

          return inputs_dict


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							XLMModelTester(self		)
          __A	:       Any      =							ConfigTester(self			,     config_class=lowerCamelCase			,     emb_dim=37		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          self.config_tester.run_common_tests()


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_model(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Dict      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_lm_head(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Any      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_simple_qa(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_qa(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Tuple      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_sequence_classif(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_token_classif(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       List[Any]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCamelCase		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False			,     lowerCamelCase=1		):


          '''simple docstring'''





          self.assertIsInstance(lowerCamelCase			,     lowerCamelCase		)
          self.assertListEqual(
              [isinstance(lowerCamelCase			,     lowerCamelCase		) for iter_attentions in attentions]			,     [True] * len(lowerCamelCase		)		)
          self.assertEqual(len(lowerCamelCase		)			,     (max_length - min_length) * num_beam_groups		)

          for idx, iter_attentions in enumerate(lowerCamelCase		):
               # adds PAD dummy token
               __A	:       Optional[Any]      =							min_length + idx + 1
               __A	:       Optional[int]      =							min_length + idx + 1

               __A	:       List[Any]      =							(
                   batch_size * num_beam_groups,
                   config.num_attention_heads,
                   tgt_len,
                   src_len,
               )
               # check attn size
               self.assertListEqual(
                   [layer_attention.shape for layer_attention in iter_attentions]			,     [expected_shape] * len(lowerCamelCase		)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False			,     lowerCamelCase=1		):


          '''simple docstring'''





          self.assertIsInstance(lowerCamelCase			,     lowerCamelCase		)
          self.assertListEqual(
              [isinstance(lowerCamelCase			,     lowerCamelCase		) for iter_hidden_states in hidden_states]			,     [True] * len(lowerCamelCase		)			,     )
          self.assertEqual(len(lowerCamelCase		)			,     (max_length - min_length) * num_beam_groups		)

          for idx, iter_hidden_states in enumerate(lowerCamelCase		):
               # adds PAD dummy token
               __A	:       Dict      =							min_length + idx + 1
               __A	:       Union[str, Any]      =							(batch_size * num_beam_groups, seq_len, config.hidden_size)
               # check hidden size
               self.assertListEqual(
                   [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]			,     [expected_shape] * len(lowerCamelCase		)			,     )
          pass


     @slow
     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __A	:       Any      =							XLMModel.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)







@require_torch
class 							__magic_name__	(       unittest.TestCase ):

     """simple docstring"""






     @slow
     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Tuple      =							XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"		)
          model.to(lowerCamelCase		)
          __A	:       Optional[int]      =							torch.tensor([[14, 447]]			,     dtype=torch.long			,     device=lowerCamelCase		)  # the president
          __A	:       Optional[Any]      =							[
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
          ]  # the president the president the president the president the president the president the president the president the president the president
          # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
          __A	:       Union[str, Any]      =							model.generate(lowerCamelCase			,     do_sample=lowerCamelCase		)
          self.assertListEqual(output_ids[0].cpu().numpy().tolist()			,     lowerCamelCase		)

