

import argparse
import os
import re

import packaging.version


A_       						=							"examples/"
A_       						=							{
    "examples": (re.compile(R"^check_min_version\(\"[^\"]+\"\)\s*$", re.MULTILINE), "check_min_version(\"VERSION\")\n"),
    "init": (re.compile(R"^__version__\s+=\s+\"([^\"]+)\"\s*$", re.MULTILINE), "__version__ = \"VERSION\"\n"),
    "setup": (re.compile(R"^(\s*)version\s*=\s*\"[^\"]+\",", re.MULTILINE), R"\1version=\"VERSION\","),
    "doc": (re.compile(R"^(\s*)release\s*=\s*\"[^\"]+\"$", re.MULTILINE), "release = \"VERSION\"\n"),
}
A_       						=							{
    "init": "src/transformers/__init__.py",
    "setup": "setup.py",
}
A_       						=							"README.md"





def    A_  ( snake_case      ,       snake_case      ,       snake_case ):






  with open(__SCREAMING_SNAKE_CASE      ,       "r"      ,       encoding="utf-8"      ,       newline="\n" ) as f:
    SCREAMING_SNAKE_CASE:Dict						      =					f.read()
  SCREAMING_SNAKE_CASE:int						      =					REPLACE_PATTERNS[pattern]
  SCREAMING_SNAKE_CASE:int						      =					replace.replace("VERSION"      ,       __SCREAMING_SNAKE_CASE )
  SCREAMING_SNAKE_CASE:Any						      =					re_pattern.sub(__SCREAMING_SNAKE_CASE      ,       __SCREAMING_SNAKE_CASE )
  with open(__SCREAMING_SNAKE_CASE      ,       "w"      ,       encoding="utf-8"      ,       newline="\n" ) as f:
    f.write(__SCREAMING_SNAKE_CASE )





def    A_  ( snake_case ):






  for folder, directories, fnames in os.walk(__SCREAMING_SNAKE_CASE ):
    # Removing some of the folders with non-actively maintained examples from the walk
    if "research_projects" in directories:
      directories.remove("research_projects" )
    if "legacy" in directories:
      directories.remove("legacy" )
    for fname in fnames:
      if fname.endswith(".py" ):
        update_version_in_file(os.path.join(__SCREAMING_SNAKE_CASE      ,       __SCREAMING_SNAKE_CASE )      ,       __SCREAMING_SNAKE_CASE      ,       pattern="examples" )





def    A_  ( snake_case      ,       snake_case=False ):






  for pattern, fname in REPLACE_FILES.items():
    update_version_in_file(__SCREAMING_SNAKE_CASE      ,       __SCREAMING_SNAKE_CASE      ,       __SCREAMING_SNAKE_CASE )
  if not patch:
    update_version_in_examples(__SCREAMING_SNAKE_CASE )





def    A_  ( ):
  SCREAMING_SNAKE_CASE:Union[str, Any]						      =					"🤗 Transformers currently provides the following architectures"
  SCREAMING_SNAKE_CASE:str						      =					"1. Want to contribute a new model?"
  with open(__SCREAMING_SNAKE_CASE      ,       "r"      ,       encoding="utf-8"      ,       newline="\n" ) as f:
    SCREAMING_SNAKE_CASE:int						      =					f.readlines()

  # Find the start of the list.
  SCREAMING_SNAKE_CASE:str						      =					0
  while not lines[start_index].startswith(_start_prompt ):
    start_index += 1
  start_index += 1

  SCREAMING_SNAKE_CASE:List[str]						      =					start_index
  # Update the lines in the model list.
  while not lines[index].startswith(_end_prompt ):
    if lines[index].startswith("1." ):
      SCREAMING_SNAKE_CASE:int						      =					lines[index].replace(
          "https://huggingface.co/docs/transformers/main/model_doc"      ,       "https://huggingface.co/docs/transformers/model_doc"      ,       )
    index += 1

  with open(__SCREAMING_SNAKE_CASE      ,       "w"      ,       encoding="utf-8"      ,       newline="\n" ) as f:
    f.writelines(__SCREAMING_SNAKE_CASE )





def    A_  ( ):






  with open(REPLACE_FILES["init"]      ,       "r" ) as f:
    SCREAMING_SNAKE_CASE:Tuple						      =					f.read()
  SCREAMING_SNAKE_CASE:List[Any]						      =					REPLACE_PATTERNS["init"][0].search(__SCREAMING_SNAKE_CASE ).groups()[0]
  return packaging.version.parse(__SCREAMING_SNAKE_CASE )





def    A_  ( snake_case=False ):
  SCREAMING_SNAKE_CASE:List[Any]						      =					get_version()
  if patch and default_version.is_devrelease:
    raise ValueError("Can't create a patch version from the dev branch, checkout a released version!" )
  if default_version.is_devrelease:
    SCREAMING_SNAKE_CASE:Any						      =					default_version.base_version
  elif patch:
    SCREAMING_SNAKE_CASE:List[Any]						      =					F'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
  else:
    SCREAMING_SNAKE_CASE:str						      =					F'''{default_version.major}.{default_version.minor + 1}.0'''

  # Now let's ask nicely if that's the right one.
  SCREAMING_SNAKE_CASE:Optional[Any]						      =					input(F'''Which version are you releasing? [{default_version}]''' )
  if len(__SCREAMING_SNAKE_CASE ) == 0:
    SCREAMING_SNAKE_CASE:Any						      =					default_version

  print(F'''Updating version to {version}.''' )
  global_version_update(__SCREAMING_SNAKE_CASE      ,       patch=__SCREAMING_SNAKE_CASE )
  if not patch:
    print("Cleaning main README, don't forget to run `make fix-copies`." )
    clean_main_ref_in_model_list()





def    A_  ( ):
  SCREAMING_SNAKE_CASE:int						      =					get_version()
  SCREAMING_SNAKE_CASE:Tuple						      =					F'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
  SCREAMING_SNAKE_CASE:Optional[Any]						      =					current_version.base_version

  # Check with the user we got that right.
  SCREAMING_SNAKE_CASE:Tuple						      =					input(F'''Which version are we developing now? [{dev_version}]''' )
  if len(__SCREAMING_SNAKE_CASE ) == 0:
    SCREAMING_SNAKE_CASE:Union[str, Any]						      =					dev_version

  print(F'''Updating version to {version}.''' )
  global_version_update(__SCREAMING_SNAKE_CASE )
  print("Cleaning main README, don't forget to run `make fix-copies`." )
  clean_main_ref_in_model_list()


if __name__ == "__main__":
    A_       						=							argparse.ArgumentParser()
    parser.add_argument("--post_release", action="store_true", help="Whether this is pre or post release.")
    parser.add_argument("--patch", action="store_true", help="Whether or not this is a patch release.")
    A_       						=							parser.parse_args()
    if not args.post_release:
        pre_release_work(patch=args.patch)
    elif args.patch:
        print("Nothing to do after a patch :-)")
    else:
        post_release_work()









'''simple docstring'''

import os
import tempfile
import unittest

from transformers import FlaubertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

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 (
        FlaubertForMultipleChoice,
        FlaubertForQuestionAnswering,
        FlaubertForQuestionAnsweringSimple,
        FlaubertForSequenceClassification,
        FlaubertForTokenClassification,
        FlaubertModel,
        FlaubertWithLMHeadModel,
    )
    from transformers.models.flaubert.modeling_flaubert import FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST





class 							_snake_case (       _a						):
   def __init__( self			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Tuple=13     ,SCREAMING_SNAKE_CASE__			:      Optional[int]=7     ,SCREAMING_SNAKE_CASE__			:      List[Any]=True     ,SCREAMING_SNAKE_CASE__			:      List[Any]=True     ,SCREAMING_SNAKE_CASE__			:      str=True     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]=True     ,SCREAMING_SNAKE_CASE__			:      Any=True     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=False     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]=False     ,SCREAMING_SNAKE_CASE__			:      int=False     ,SCREAMING_SNAKE_CASE__			:      int=2     ,SCREAMING_SNAKE_CASE__			:      Any=99     ,SCREAMING_SNAKE_CASE__			:      Optional[int]=0     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=32     ,SCREAMING_SNAKE_CASE__			:      List[str]=5     ,SCREAMING_SNAKE_CASE__			:      Tuple=4     ,SCREAMING_SNAKE_CASE__			:      Tuple=0.1     ,SCREAMING_SNAKE_CASE__			:      str=0.1     ,SCREAMING_SNAKE_CASE__			:      Dict=512     ,SCREAMING_SNAKE_CASE__			:      Optional[int]=12     ,SCREAMING_SNAKE_CASE__			:      List[Any]=2     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=0.02     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]=3     ,SCREAMING_SNAKE_CASE__			:      Dict=4     ,SCREAMING_SNAKE_CASE__			:      Dict="last"     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=None     ,SCREAMING_SNAKE_CASE__			:      List[Any]=None     ,):
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					parent
     SCREAMING_SNAKE_CASE:Dict						      =					batch_size
     SCREAMING_SNAKE_CASE:int						      =					seq_length
     SCREAMING_SNAKE_CASE:Any						      =					is_training
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					use_input_lengths
     SCREAMING_SNAKE_CASE:List[Any]						      =					use_token_type_ids
     SCREAMING_SNAKE_CASE:Dict						      =					use_labels
     SCREAMING_SNAKE_CASE:Dict						      =					gelu_activation
     SCREAMING_SNAKE_CASE:Dict						      =					sinusoidal_embeddings
     SCREAMING_SNAKE_CASE:List[str]						      =					causal
     SCREAMING_SNAKE_CASE:List[Any]						      =					asm
     SCREAMING_SNAKE_CASE:List[str]						      =					n_langs
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					vocab_size
     SCREAMING_SNAKE_CASE:Optional[int]						      =					n_special
     SCREAMING_SNAKE_CASE:str						      =					hidden_size
     SCREAMING_SNAKE_CASE:Dict						      =					num_hidden_layers
     SCREAMING_SNAKE_CASE:Dict						      =					num_attention_heads
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					hidden_dropout_prob
     SCREAMING_SNAKE_CASE:Tuple						      =					attention_probs_dropout_prob
     SCREAMING_SNAKE_CASE:Tuple						      =					max_position_embeddings
     SCREAMING_SNAKE_CASE:List[str]						      =					type_vocab_size
     SCREAMING_SNAKE_CASE:int						      =					type_sequence_label_size
     SCREAMING_SNAKE_CASE:Any						      =					initializer_range
     SCREAMING_SNAKE_CASE:str						      =					num_labels
     SCREAMING_SNAKE_CASE:Dict						      =					num_choices
     SCREAMING_SNAKE_CASE:Any						      =					summary_type
     SCREAMING_SNAKE_CASE:int						      =					use_proj
     SCREAMING_SNAKE_CASE:int						      =					scope
   def     __UpperCamelCase						( self			:      Optional[int]							):
     SCREAMING_SNAKE_CASE:int						      =					ids_tensor([self.batch_size, self.seq_length]     ,self.vocab_size							)
     SCREAMING_SNAKE_CASE:str						      =					random_attention_mask([self.batch_size, self.seq_length]							)

     SCREAMING_SNAKE_CASE:Tuple						      =					None
     if self.use_input_lengths:
       SCREAMING_SNAKE_CASE:List[Any]						      =					(
           ids_tensor([self.batch_size]     ,vocab_size=2							) + self.seq_length - 2
       )  # small variation of seq_length

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

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

     SCREAMING_SNAKE_CASE: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     __UpperCamelCase						( self			:      Optional[int]							):
     return FlaubertConfig(
         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     ,)
   def     __UpperCamelCase						( self			:      Any     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Dict     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,):
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					FlaubertModel(config=SCREAMING_SNAKE_CASE__							)
     model.to(SCREAMING_SNAKE_CASE__							)
     model.eval()
     SCREAMING_SNAKE_CASE:Any						      =					model(SCREAMING_SNAKE_CASE__     ,lengths=SCREAMING_SNAKE_CASE__     ,langs=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Any						      =					model(SCREAMING_SNAKE_CASE__     ,langs=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					model(SCREAMING_SNAKE_CASE__							)
     self.parent.assertEqual(result.last_hidden_state.shape     ,(self.batch_size, self.seq_length, self.hidden_size)							)
   def     __UpperCamelCase						( self			:      Dict     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      str     ,):
     SCREAMING_SNAKE_CASE:Optional[int]						      =					FlaubertWithLMHeadModel(SCREAMING_SNAKE_CASE__							)
     model.to(SCREAMING_SNAKE_CASE__							)
     model.eval()

     SCREAMING_SNAKE_CASE:Optional[int]						      =					model(SCREAMING_SNAKE_CASE__     ,token_type_ids=SCREAMING_SNAKE_CASE__     ,labels=SCREAMING_SNAKE_CASE__							)
     self.parent.assertEqual(result.loss.shape     ,()							)
     self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.seq_length, self.vocab_size)							)
   def     __UpperCamelCase						( self			:      Any     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,):
     SCREAMING_SNAKE_CASE:Optional[int]						      =					FlaubertForQuestionAnsweringSimple(SCREAMING_SNAKE_CASE__							)
     model.to(SCREAMING_SNAKE_CASE__							)
     model.eval()

     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					model(SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:Dict						      =					model(SCREAMING_SNAKE_CASE__     ,start_positions=SCREAMING_SNAKE_CASE__     ,end_positions=SCREAMING_SNAKE_CASE__							)
     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			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Dict     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,):
     SCREAMING_SNAKE_CASE:str						      =					FlaubertForQuestionAnswering(SCREAMING_SNAKE_CASE__							)
     model.to(SCREAMING_SNAKE_CASE__							)
     model.eval()

     SCREAMING_SNAKE_CASE:List[Any]						      =					model(SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:Optional[Any]						      =					model(
         SCREAMING_SNAKE_CASE__     ,start_positions=SCREAMING_SNAKE_CASE__     ,end_positions=SCREAMING_SNAKE_CASE__     ,cls_index=SCREAMING_SNAKE_CASE__     ,is_impossible=SCREAMING_SNAKE_CASE__     ,p_mask=SCREAMING_SNAKE_CASE__     ,)

     SCREAMING_SNAKE_CASE:str						      =					model(
         SCREAMING_SNAKE_CASE__     ,start_positions=SCREAMING_SNAKE_CASE__     ,end_positions=SCREAMING_SNAKE_CASE__     ,cls_index=SCREAMING_SNAKE_CASE__     ,is_impossible=SCREAMING_SNAKE_CASE__     ,)

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

     SCREAMING_SNAKE_CASE:Optional[int]						      =					model(SCREAMING_SNAKE_CASE__     ,start_positions=SCREAMING_SNAKE_CASE__     ,end_positions=SCREAMING_SNAKE_CASE__							)

     ((SCREAMING_SNAKE_CASE)      ,    ):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     __UpperCamelCase						( self			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Dict     ,):
     SCREAMING_SNAKE_CASE:List[Any]						      =					FlaubertForSequenceClassification(SCREAMING_SNAKE_CASE__							)
     model.to(SCREAMING_SNAKE_CASE__							)
     model.eval()

     SCREAMING_SNAKE_CASE:Tuple						      =					model(SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					model(SCREAMING_SNAKE_CASE__     ,labels=SCREAMING_SNAKE_CASE__							)

     self.parent.assertEqual(result.loss.shape     ,()							)
     self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.type_sequence_label_size)							)
   def     __UpperCamelCase						( self			:      int     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      Any     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,):
     SCREAMING_SNAKE_CASE:List[str]						      =					self.num_labels
     SCREAMING_SNAKE_CASE:Optional[int]						      =					FlaubertForTokenClassification(SCREAMING_SNAKE_CASE__							)
     model.to(SCREAMING_SNAKE_CASE__							)
     model.eval()

     SCREAMING_SNAKE_CASE:Optional[Any]						      =					model(SCREAMING_SNAKE_CASE__     ,attention_mask=SCREAMING_SNAKE_CASE__     ,labels=SCREAMING_SNAKE_CASE__							)
     self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.seq_length, self.num_labels)							)
   def     __UpperCamelCase						( self			:      Any     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Dict     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      List[str]     ,):
     SCREAMING_SNAKE_CASE:List[str]						      =					self.num_choices
     SCREAMING_SNAKE_CASE:Any						      =					FlaubertForMultipleChoice(config=SCREAMING_SNAKE_CASE__							)
     model.to(SCREAMING_SNAKE_CASE__							)
     model.eval()
     SCREAMING_SNAKE_CASE:str						      =					input_ids.unsqueeze(1							).expand(-1     ,self.num_choices     ,-1							).contiguous()
     SCREAMING_SNAKE_CASE:Dict						      =					token_type_ids.unsqueeze(1							).expand(-1     ,self.num_choices     ,-1							).contiguous()
     SCREAMING_SNAKE_CASE:List[Any]						      =					input_mask.unsqueeze(1							).expand(-1     ,self.num_choices     ,-1							).contiguous()
     SCREAMING_SNAKE_CASE:int						      =					model(
         SCREAMING_SNAKE_CASE__     ,attention_mask=SCREAMING_SNAKE_CASE__     ,token_type_ids=SCREAMING_SNAKE_CASE__     ,labels=SCREAMING_SNAKE_CASE__     ,)
     self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_choices)							)







   def     __UpperCamelCase						( self			:      Any							):
     SCREAMING_SNAKE_CASE:str						      =					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
     )      ,    (
         SCREAMING_SNAKE_CASE
     )      ,    
     ):Tuple						      =					config_and_inputs
     SCREAMING_SNAKE_CASE:Tuple						      =					{
         "input_ids": input_ids,
         "token_type_ids": token_type_ids,
         "lengths": input_lengths,
         "attention_mask": input_mask,
     }
     return config, inputs_dict





@require_torch
class 							_snake_case (       _a	,  _a	,  unittest.TestCase						):
   _A       :     int       =					(
       (
           FlaubertModel,
           FlaubertWithLMHeadModel,
           FlaubertForQuestionAnswering,
           FlaubertForQuestionAnsweringSimple,
           FlaubertForSequenceClassification,
           FlaubertForTokenClassification,
           FlaubertForMultipleChoice,
       )
       if is_torch_available()
       else ()
   )
   _A       :     Optional[Any]       =					(
       {
           '''feature-extraction''': FlaubertModel,
           '''fill-mask''': FlaubertWithLMHeadModel,
           '''question-answering''': FlaubertForQuestionAnsweringSimple,
           '''text-classification''': FlaubertForSequenceClassification,
           '''token-classification''': FlaubertForTokenClassification,
           '''zero-shot''': FlaubertForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   def     __UpperCamelCase						( self			:      str     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      str     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]							):
     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     __UpperCamelCase						( self			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      int=False							):
     SCREAMING_SNAKE_CASE:Any						      =					super()._prepare_for_class(SCREAMING_SNAKE_CASE__     ,SCREAMING_SNAKE_CASE__     ,return_labels=SCREAMING_SNAKE_CASE__							)

     if return_labels:
       if model_class.__name__ == "FlaubertForQuestionAnswering":
         SCREAMING_SNAKE_CASE:Dict						      =					torch.zeros(
             self.model_tester.batch_size     ,dtype=torch.long     ,device=SCREAMING_SNAKE_CASE__							)
         SCREAMING_SNAKE_CASE:int						      =					torch.zeros(
             self.model_tester.batch_size     ,dtype=torch.long     ,device=SCREAMING_SNAKE_CASE__							)

     return inputs_dict
   def     __UpperCamelCase						( self			:      Optional[int]							):
     SCREAMING_SNAKE_CASE:int						      =					FlaubertModelTester(self							)
     SCREAMING_SNAKE_CASE:Dict						      =					ConfigTester(self     ,config_class=SCREAMING_SNAKE_CASE__     ,emb_dim=37							)
   def     __UpperCamelCase						( self			:      Any							):
     self.config_tester.run_common_tests()
   def     __UpperCamelCase						( self			:      Any							):
     SCREAMING_SNAKE_CASE:Any						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_model(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      Optional[int]							):
     SCREAMING_SNAKE_CASE:Dict						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_lm_head(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      str							):
     SCREAMING_SNAKE_CASE:str						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_simple_qa(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      Any							):
     SCREAMING_SNAKE_CASE:Dict						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_qa(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      Optional[Any]							):
     SCREAMING_SNAKE_CASE:Dict						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_sequence_classif(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      List[Any]							):
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_token_classif(*SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      int							):
     SCREAMING_SNAKE_CASE:List[Any]						      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_multiple_choice(*SCREAMING_SNAKE_CASE__							)
   @slow
   def     __UpperCamelCase						( self			:      List[str]							):
     for model_name in FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       SCREAMING_SNAKE_CASE:Tuple						      =					FlaubertModel.from_pretrained(SCREAMING_SNAKE_CASE__							)
       self.assertIsNotNone(SCREAMING_SNAKE_CASE__							)







   @slow
   @require_torch_gpu
   def     __UpperCamelCase						( self			:      str							):
     SCREAMING_SNAKE_CASE      ,    SCREAMING_SNAKE_CASE:int						      =					self.model_tester.prepare_config_and_inputs_for_common()
     for model_class in self.all_model_classes:
       # FlauBertForMultipleChoice behaves incorrectly in JIT environments.
       if model_class == FlaubertForMultipleChoice:
         return

       SCREAMING_SNAKE_CASE:Union[str, Any]						      =					True
       SCREAMING_SNAKE_CASE:Optional[int]						      =					model_class(config=SCREAMING_SNAKE_CASE__							)

       SCREAMING_SNAKE_CASE:Any						      =					self._prepare_for_class(SCREAMING_SNAKE_CASE__     ,SCREAMING_SNAKE_CASE__							)
       SCREAMING_SNAKE_CASE:Any						      =					torch.jit.trace(
           SCREAMING_SNAKE_CASE__     ,(inputs_dict["input_ids"].to("cpu"							), inputs_dict["attention_mask"].to("cpu"							))							)

       with tempfile.TemporaryDirectory() as tmp:
         torch.jit.save(SCREAMING_SNAKE_CASE__     ,os.path.join(SCREAMING_SNAKE_CASE__     ,"traced_model.pt"							)							)
         SCREAMING_SNAKE_CASE:Optional[Any]						      =					torch.jit.load(os.path.join(SCREAMING_SNAKE_CASE__     ,"traced_model.pt"							)     ,map_location=SCREAMING_SNAKE_CASE__							)
         loaded(inputs_dict["input_ids"].to(SCREAMING_SNAKE_CASE__							)     ,inputs_dict["attention_mask"].to(SCREAMING_SNAKE_CASE__							)							)





@require_torch
class 							_snake_case (       unittest.TestCase						):
   @slow
   def     __UpperCamelCase						( self			:      List[str]							):
     SCREAMING_SNAKE_CASE:Optional[int]						      =					FlaubertModel.from_pretrained("flaubert/flaubert_base_cased"							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]							)
     with torch.no_grad():
       SCREAMING_SNAKE_CASE:Union[str, Any]						      =					model(SCREAMING_SNAKE_CASE__							)[0]
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					torch.Size((1, 11, 768)							)
     self.assertEqual(output.shape     ,SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:int						      =					torch.tensor(
         [[[-2.6_251, -1.4_298, -0.0_227], [-2.8_510, -1.6_387, 0.2_258], [-2.8_114, -1.1_832, -0.3_066]]]							)

     self.assertTrue(torch.allclose(output[:, :3, :3]     ,SCREAMING_SNAKE_CASE__     ,atol=1e-4							)							)






