



"""simple docstring"""
import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
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_PRETRAINING_MAPPING,
           NezhaForMaskedLM,
           NezhaForMultipleChoice,
           NezhaForNextSentencePrediction,
           NezhaForPreTraining,
           NezhaForQuestionAnswering,
           NezhaForSequenceClassification,
           NezhaForTokenClassification,
           NezhaModel,
       )
       from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST


class    SCREAMING_SNAKE_CASE__ :

    def __init__(				self			:				int ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				Optional[Any]=1_3 ,  lowerCAmelCase_			:				List[Any]=7 ,  lowerCAmelCase_			:				List[str]=True ,  lowerCAmelCase_			:				Any=True ,  lowerCAmelCase_			:				List[Any]=True ,  lowerCAmelCase_			:				Dict=True ,  lowerCAmelCase_			:				str=9_9 ,  lowerCAmelCase_			:				List[str]=3_2 ,  lowerCAmelCase_			:				Union[str, Any]=5 ,  lowerCAmelCase_			:				Dict=4 ,  lowerCAmelCase_			:				List[str]=3_7 ,  lowerCAmelCase_			:				Tuple="gelu" ,  lowerCAmelCase_			:				Optional[int]=0.1 ,  lowerCAmelCase_			:				Union[str, Any]=0.1 ,  lowerCAmelCase_			:				Any=1_2_8 ,  lowerCAmelCase_			:				int=3_2 ,  lowerCAmelCase_			:				Dict=1_6 ,  lowerCAmelCase_			:				Union[str, Any]=2 ,  lowerCAmelCase_			:				List[str]=0.02 ,  lowerCAmelCase_			:				Union[str, Any]=3 ,  lowerCAmelCase_			:				int=4 ,  lowerCAmelCase_			:				Tuple=None ,  ):







      """simple docstring"""







      lowercase_								= parent
      lowercase_								= batch_size
      lowercase_								= seq_length
      lowercase_								= is_training
      lowercase_								= use_input_mask
      lowercase_								= use_token_type_ids
      lowercase_								= use_labels
      lowercase_								= vocab_size
      lowercase_								= hidden_size
      lowercase_								= num_hidden_layers
      lowercase_								= num_attention_heads
      lowercase_								= intermediate_size
      lowercase_								= hidden_act
      lowercase_								= hidden_dropout_prob
      lowercase_								= attention_probs_dropout_prob
      lowercase_								= max_position_embeddings
      lowercase_								= type_vocab_size
      lowercase_								= type_sequence_label_size
      lowercase_								= initializer_range
      lowercase_								= num_labels
      lowercase_								= num_choices
      lowercase_								= scope

    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







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

      lowercase_								= None
      if self.use_input_mask:
        lowercase_								= random_attention_mask([self.batch_size, self.seq_length])

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

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

      lowercase_								= self.get_config()

      return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      return NezhaConfig(
          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 ,  is_decoder=lowerCAmelCase_ ,  initializer_range=self.initializer_range ,  )

    def 					_UpperCAmelCase	(				self			:				Tuple):







      """simple docstring"""







      (
          (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,        
      )								= self.prepare_config_and_inputs()

      lowercase_								= True
      lowercase_								= floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
      lowercase_								= ids_tensor([self.batch_size, self.seq_length] ,  vocab_size=2)

      return (
          config,
          input_ids,
          token_type_ids,
          input_mask,
          sequence_labels,
          token_labels,
          choice_labels,
          encoder_hidden_states,
          encoder_attention_mask,
      )

    def 					_UpperCAmelCase	(				self			:				Dict ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				int):







      """simple docstring"""







      lowercase_								= NezhaModel(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_)
      lowercase_								= model(lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_)
      lowercase_								= model(lowerCAmelCase_)
      self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.hidden_size))
      self.parent.assertEqual(result.pooler_output.shape ,  (self.batch_size, self.hidden_size))

    def 					_UpperCAmelCase	(				self			:				Optional[int] ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Tuple ,  ):







      """simple docstring"""







      lowercase_								= True
      lowercase_								= NezhaModel(lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(
          lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_ ,  encoder_hidden_states=lowerCAmelCase_ ,  encoder_attention_mask=lowerCAmelCase_ ,  )
      lowercase_								= model(
          lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_ ,  encoder_hidden_states=lowerCAmelCase_ ,  )
      lowercase_								= model(lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_)
      self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.hidden_size))
      self.parent.assertEqual(result.pooler_output.shape ,  (self.batch_size, self.hidden_size))

    def 					_UpperCAmelCase	(				self			:				Optional[Any] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				int):







      """simple docstring"""







      lowercase_								= NezhaForMaskedLM(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_ ,  labels=lowerCAmelCase_)
      self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length, self.vocab_size))

    def 					_UpperCAmelCase	(				self			:				Any ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				Any):







      """simple docstring"""







      lowercase_								= NezhaForNextSentencePrediction(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(
          lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_ ,  labels=lowerCAmelCase_ ,  )
      self.parent.assertEqual(result.logits.shape ,  (self.batch_size, 2))

    def 					_UpperCAmelCase	(				self			:				Any ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Union[str, Any]):







      """simple docstring"""







      lowercase_								= NezhaForPreTraining(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(
          lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_ ,  labels=lowerCAmelCase_ ,  next_sentence_label=lowerCAmelCase_ ,  )
      self.parent.assertEqual(result.prediction_logits.shape ,  (self.batch_size, self.seq_length, self.vocab_size))
      self.parent.assertEqual(result.seq_relationship_logits.shape ,  (self.batch_size, 2))

    def 					_UpperCAmelCase	(				self			:				Dict ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				Optional[int] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Any):







      """simple docstring"""







      lowercase_								= NezhaForQuestionAnswering(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(
          lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_ ,  start_positions=lowerCAmelCase_ ,  end_positions=lowerCAmelCase_ ,  )
      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			:				Optional[int] ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				int):







      """simple docstring"""







      lowercase_								= self.num_labels
      lowercase_								= NezhaForSequenceClassification(lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_ ,  labels=lowerCAmelCase_)
      self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels))

    def 					_UpperCAmelCase	(				self			:				Tuple ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				List[str] ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Optional[int]):







      """simple docstring"""







      lowercase_								= self.num_labels
      lowercase_								= NezhaForTokenClassification(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_ ,  token_type_ids=lowerCAmelCase_ ,  labels=lowerCAmelCase_)
      self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length, self.num_labels))

    def 					_UpperCAmelCase	(				self			:				Tuple ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Optional[Any] ,  lowerCAmelCase_			:				Dict ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				Optional[Any]):







      """simple docstring"""







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




    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







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







@require_torch
class    SCREAMING_SNAKE_CASE__ (							__UpperCAmelCase      ,  __UpperCAmelCase      ,  __UpperCAmelCase      ,  unittest.TestCase   ):
    lowercase__      =   (
        (
            NezhaModel,
            NezhaForMaskedLM,
            NezhaForMultipleChoice,
            NezhaForNextSentencePrediction,
            NezhaForPreTraining,
            NezhaForQuestionAnswering,
            NezhaForSequenceClassification,
            NezhaForTokenClassification,
        )
        if is_torch_available()
        else ()
    )
    lowercase__      =   (
        {
            "feature-extraction": NezhaModel,
            "fill-mask": NezhaForMaskedLM,
            "question-answering": NezhaForQuestionAnswering,
            "text-classification": NezhaForSequenceClassification,
            "token-classification": NezhaForTokenClassification,
            "zero-shot": NezhaForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    lowercase__      =   True

    def 					_UpperCAmelCase	(				self			:				int ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				int=False):







      """simple docstring"""







      lowercase_								= super()._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_ ,  return_labels=lowerCAmelCase_)

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

    def 					_UpperCAmelCase	(				self			:				Optional[int]):







      """simple docstring"""







      lowercase_								= NezhaModelTester(self)
      lowercase_								= ConfigTester(self ,  config_class=lowerCAmelCase_ ,  hidden_size=3_7)

    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      self.config_tester.run_common_tests()

    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs_for_decoder()
      self.model_tester.create_and_check_model_as_decoder(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      (
          (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,    (
          lowercase_    
      )					,        
      )								= self.model_tester.prepare_config_and_inputs_for_decoder()

      lowercase_								= None

      self.model_tester.create_and_check_model_as_decoder(
          lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  )

    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_next_sequence_prediction(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				Tuple):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_)

    @slow
    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowercase_								= NezhaModel.from_pretrained(lowerCAmelCase_)
        self.assertIsNotNone(lowerCAmelCase_)




    @slow
    @require_torch_gpu
    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes:
        # NezhaForMultipleChoice behaves incorrectly in JIT environments.
        if model_class == NezhaForMultipleChoice:
          return

        lowercase_								= True
        lowercase_								= model_class(config=lowerCAmelCase_)

        lowercase_								= self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_)
        lowercase_								= torch.jit.trace(
            lowerCAmelCase_ ,  (inputs_dict["""input_ids"""].to("""cpu"""), inputs_dict["""attention_mask"""].to("""cpu""")))

        with tempfile.TemporaryDirectory() as tmp:
          torch.jit.save(lowerCAmelCase_ ,  os.path.join(lowerCAmelCase_ ,  """bert.pt"""))
          lowercase_								= torch.jit.load(os.path.join(lowerCAmelCase_ ,  """bert.pt""") ,  map_location=lowerCAmelCase_)
          loaded(inputs_dict["""input_ids"""].to(lowerCAmelCase_) ,  inputs_dict["""attention_mask"""].to(lowerCAmelCase_))







@require_torch
class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):

    @slow
    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      lowercase_								= NezhaModel.from_pretrained("""sijunhe/nezha-cn-base""")
      lowercase_								= torch.tensor([[0, 1, 2, 3, 4, 5]])
      lowercase_								= torch.tensor([[0, 1, 1, 1, 1, 1]])
      with torch.no_grad():
        lowercase_								= model(lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_)[0]
      lowercase_								= torch.Size((1, 6, 7_6_8))
      self.assertEqual(output.shape ,  lowerCAmelCase_)
      lowercase_								= torch.tensor([[[0.0_685, 0.2_441, 0.1_102], [0.0_600, 0.1_906, 0.1_349], [0.0_221, 0.0_819, 0.0_586]]])

      self.assertTrue(torch.allclose(output[:, 1:4, 1:4] ,  lowerCAmelCase_ ,  atol=1E-4))




    @slow
    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_								= NezhaForMaskedLM.from_pretrained("""sijunhe/nezha-cn-base""")
      lowercase_								= torch.tensor([[0, 1, 2, 3, 4, 5]])
      lowercase_								= torch.tensor([[1, 1, 1, 1, 1, 1]])
      with torch.no_grad():
        lowercase_								= model(lowerCAmelCase_ ,  attention_mask=lowerCAmelCase_)[0]
      lowercase_								= torch.Size((1, 6, 2_1_1_2_8))
      self.assertEqual(output.shape ,  lowerCAmelCase_)
      lowercase_								= torch.tensor(
          [[-2.7_939, -1.7_902, -2.2_189], [-2.8_585, -1.8_908, -2.3_723], [-2.6_499, -1.7_750, -2.2_558]])

      self.assertTrue(torch.allclose(output[:, 1:4, 1:4] ,  lowerCAmelCase_ ,  atol=1E-4))






"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase						:		Any			= {"configuration_xglm": ["XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "XGLMConfig"]}

try:
       if not is_sentencepiece_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase						:		List[str]			= ["XGLMTokenizer"]

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase						:		Dict			= ["XGLMTokenizerFast"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase						:		Tuple			= [
           "XGLM_PRETRAINED_MODEL_ARCHIVE_LIST",
           "XGLMForCausalLM",
           "XGLMModel",
           "XGLMPreTrainedModel",
       ]


try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase						:		int			= [
           "FlaxXGLMForCausalLM",
           "FlaxXGLMModel",
           "FlaxXGLMPreTrainedModel",
       ]


try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase						:		List[str]			= [
           "TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST",
           "TFXGLMForCausalLM",
           "TFXGLMModel",
           "TFXGLMPreTrainedModel",
       ]


if TYPE_CHECKING:
       from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig

       try:
              if not is_sentencepiece_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_xglm import XGLMTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_xglm_fast import XGLMTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel

       try:
              if not is_flax_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_xglm import (
                  TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFXGLMForCausalLM,
                  TFXGLMModel,
                  TFXGLMPreTrainedModel,
              )


else:
       import sys

       UpperCAmelCase						:		Any			= _LazyModule(__name__, globals()["__file__"], _import_structure)

