
from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers.models.layoutlm.modeling_tf_layoutlm import (
          TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFLayoutLMForMaskedLM,
          TFLayoutLMForQuestionAnswering,
          TFLayoutLMForSequenceClassification,
          TFLayoutLMForTokenClassification,
          TFLayoutLMModel,
      )



class 		UpperCamelCase__  :
   def __init__(self :					Any					,				snake_case_ :					List[str]					,				snake_case_ :					Union[str, Any]=1_3					,				snake_case_ :					Optional[Any]=7					,				snake_case_ :					List[str]=True					,				snake_case_ :					int=True					,				snake_case_ :					Union[str, Any]=True					,				snake_case_ :					Optional[Any]=True					,				snake_case_ :					List[Any]=9_9					,				snake_case_ :					Dict=3_2					,				snake_case_ :					Optional[Any]=2					,				snake_case_ :					int=4					,				snake_case_ :					Union[str, Any]=3_7					,				snake_case_ :					List[str]="gelu"					,				snake_case_ :					Tuple=0.1					,				snake_case_ :					int=0.1					,				snake_case_ :					str=5_1_2					,				snake_case_ :					Any=1_6					,				snake_case_ :					int=2					,				snake_case_ :					str=0.02					,				snake_case_ :					List[str]=3					,				snake_case_ :					Any=4					,				snake_case_ :					Any=None					,				snake_case_ :					Any=1_0_0_0					,				):
    __a :  List[Any]						=  parent
    __a :  List[str]						=  batch_size
    __a :  List[str]						=  seq_length
    __a :  str						=  is_training
    __a :  List[Any]						=  use_input_mask
    __a :  str						=  use_token_type_ids
    __a :  Optional[Any]						=  use_labels
    __a :  int						=  vocab_size
    __a :  Dict						=  hidden_size
    __a :  Tuple						=  num_hidden_layers
    __a :  Dict						=  num_attention_heads
    __a :  int						=  intermediate_size
    __a :  str						=  hidden_act
    __a :  str						=  hidden_dropout_prob
    __a :  Any						=  attention_probs_dropout_prob
    __a :  Optional[int]						=  max_position_embeddings
    __a :  Union[str, Any]						=  type_vocab_size
    __a :  Union[str, Any]						=  type_sequence_label_size
    __a :  List[Any]						=  initializer_range
    __a :  Dict						=  num_labels
    __a :  Optional[Any]						=  num_choices
    __a :  int						=  scope
    __a :  Dict						=  range_bbox
   def       lowerCAmelCase			(self :					str   ):
    __a :  Dict						=  ids_tensor([self.batch_size, self.seq_length]					,				self.vocab_size   )

    # convert bbox to numpy since TF does not support item assignment
    __a :  List[str]						=  ids_tensor([self.batch_size, self.seq_length, 4]					,				self.range_bbox   ).numpy()
    # Ensure that bbox is legal
    for i in range(bbox.shape[0]   ):
     for j in range(bbox.shape[1]   ):
      if bbox[i, j, 3] < bbox[i, j, 1]:
       __a :  List[str]						=  bbox[i, j, 3]
       __a :  Dict						=  bbox[i, j, 1]
       __a :  List[Any]						=  t
      if bbox[i, j, 2] < bbox[i, j, 0]:
       __a :  List[Any]						=  bbox[i, j, 2]
       __a :  List[Any]						=  bbox[i, j, 0]
       __a :  List[Any]						=  t
    __a :  int						=  tf.convert_to_tensor(snake_case_   )

    __a :  int						=  None
    if self.use_input_mask:
     __a :  Dict						=  random_attention_mask([self.batch_size, self.seq_length]   )

    __a :  List[Any]						=  None
    if self.use_token_type_ids:
     __a :  Optional[Any]						=  ids_tensor([self.batch_size, self.seq_length]					,				self.type_vocab_size   )

    __a :  Optional[Any]						=  None
    __a :  Optional[Any]						=  None
    __a :  str						=  None
    if self.use_labels:
     __a :  Union[str, 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 :  Dict						=  ids_tensor([self.batch_size]					,				self.num_choices   )

    __a :  List[Any]						=  LayoutLMConfig(
        vocab_size=self.vocab_size					,				hidden_size=self.hidden_size					,				num_hidden_layers=self.num_hidden_layers					,				num_attention_heads=self.num_attention_heads					,				intermediate_size=self.intermediate_size					,				hidden_act=self.hidden_act					,				hidden_dropout_prob=self.hidden_dropout_prob					,				attention_probs_dropout_prob=self.attention_probs_dropout_prob					,				max_position_embeddings=self.max_position_embeddings					,				type_vocab_size=self.type_vocab_size					,				initializer_range=self.initializer_range					,				)

    return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
   def       lowerCAmelCase			(self :					List[Any]					,				snake_case_ :					str					,				snake_case_ :					int					,				snake_case_ :					Optional[int]					,				snake_case_ :					Optional[Any]					,				snake_case_ :					List[Any]					,				snake_case_ :					str					,				snake_case_ :					str					,				snake_case_ :					Optional[Any]   ):
    __a :  Any						=  TFLayoutLMModel(config=snake_case_   )

    __a :  str						=  model(snake_case_					,				snake_case_					,				attention_mask=snake_case_					,				token_type_ids=snake_case_   )
    __a :  str						=  model(snake_case_					,				snake_case_					,				token_type_ids=snake_case_   )
    __a :  Union[str, Any]						=  model(snake_case_					,				snake_case_   )
    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       lowerCAmelCase			(self :					List[str]					,				snake_case_ :					List[Any]					,				snake_case_ :					List[str]					,				snake_case_ :					List[str]					,				snake_case_ :					Dict					,				snake_case_ :					str					,				snake_case_ :					Optional[int]					,				snake_case_ :					int					,				snake_case_ :					Union[str, Any]   ):
    __a :  List[str]						=  TFLayoutLMForMaskedLM(config=snake_case_   )

    __a :  List[str]						=  model(snake_case_					,				snake_case_					,				attention_mask=snake_case_					,				token_type_ids=snake_case_					,				labels=snake_case_   )
    self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.seq_length, self.vocab_size)   )
   def       lowerCAmelCase			(self :					Optional[int]					,				snake_case_ :					Union[str, Any]					,				snake_case_ :					Any					,				snake_case_ :					List[Any]					,				snake_case_ :					Tuple					,				snake_case_ :					Optional[Any]					,				snake_case_ :					Any					,				snake_case_ :					Union[str, Any]					,				snake_case_ :					Union[str, Any]   ):
    __a :  List[str]						=  self.num_labels
    __a :  Dict						=  TFLayoutLMForSequenceClassification(config=snake_case_   )

    __a :  int						=  model(snake_case_					,				snake_case_					,				attention_mask=snake_case_					,				token_type_ids=snake_case_   )
    self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.num_labels)   )
   def       lowerCAmelCase			(self :					Optional[int]					,				snake_case_ :					List[str]					,				snake_case_ :					List[Any]					,				snake_case_ :					Optional[int]					,				snake_case_ :					List[str]					,				snake_case_ :					Optional[Any]					,				snake_case_ :					Tuple					,				snake_case_ :					int					,				snake_case_ :					Optional[Any]   ):
    __a :  List[str]						=  self.num_labels
    __a :  List[Any]						=  TFLayoutLMForTokenClassification(config=snake_case_   )

    __a :  Any						=  model(snake_case_					,				snake_case_					,				attention_mask=snake_case_					,				token_type_ids=snake_case_					,				labels=snake_case_   )
    self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.seq_length, self.num_labels)   )
   def       lowerCAmelCase			(self :					str					,				snake_case_ :					int					,				snake_case_ :					Dict					,				snake_case_ :					Union[str, Any]					,				snake_case_ :					Optional[int]					,				snake_case_ :					List[Any]					,				snake_case_ :					Union[str, Any]					,				snake_case_ :					List[Any]					,				snake_case_ :					int   ):
    __a :  Union[str, Any]						=  TFLayoutLMForQuestionAnswering(config=snake_case_   )

    __a :  Tuple						=  model(snake_case_					,				snake_case_					,				attention_mask=snake_case_					,				token_type_ids=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       lowerCAmelCase			(self :					Dict   ):
    __a :  Dict						=  self.prepare_config_and_inputs()
    (
        (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       (
        __a
    )				,       
    ) :  int						=  config_and_inputs
    __a :  Optional[int]						=  {
        '''input_ids''': input_ids,
        '''bbox''': bbox,
        '''token_type_ids''': token_type_ids,
        '''attention_mask''': input_mask,
    }
    return config, inputs_dict





@require_tf
class 		UpperCamelCase__  (       __lowercase    ,__lowercase    ,unittest.TestCase    ):
   _SCREAMING_SNAKE_CASE      :							Tuple	       =      (
       (
           TFLayoutLMModel,
           TFLayoutLMForMaskedLM,
           TFLayoutLMForTokenClassification,
           TFLayoutLMForSequenceClassification,
           TFLayoutLMForQuestionAnswering,
       )
       if is_tf_available()
       else ()
   )
   _SCREAMING_SNAKE_CASE      :							List[str]	       =      (
       {
           "feature-extraction": TFLayoutLMModel,
           "fill-mask": TFLayoutLMForMaskedLM,
           "text-classification": TFLayoutLMForSequenceClassification,
           "token-classification": TFLayoutLMForTokenClassification,
           "zero-shot": TFLayoutLMForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   _SCREAMING_SNAKE_CASE      :							List[Any]	       =      False
   _SCREAMING_SNAKE_CASE      :							Dict	       =      True
   _SCREAMING_SNAKE_CASE      :							Optional[int]	       =      10
   def       lowerCAmelCase			(self :					List[Any]   ):
    __a :  Union[str, Any]						=  TFLayoutLMModelTester(self   )
    __a :  Optional[Any]						=  ConfigTester(self					,				config_class=snake_case_					,				hidden_size=3_7   )
   def       lowerCAmelCase			(self :					Tuple   ):
    self.config_tester.run_common_tests()
   def       lowerCAmelCase			(self :					Dict   ):
    __a :  List[str]						=  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*snake_case_   )
   def       lowerCAmelCase			(self :					List[str]   ):
    __a :  int						=  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_lm(*snake_case_   )
   def       lowerCAmelCase			(self :					Any   ):
    __a :  Dict						=  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_sequence_classification(*snake_case_   )
   def       lowerCAmelCase			(self :					str   ):
    __a :  Tuple						=  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_token_classification(*snake_case_   )
   def       lowerCAmelCase			(self :					Dict   ):
    __a :  List[str]						=  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_question_answering(*snake_case_   )
   @slow
   def       lowerCAmelCase			(self :					Tuple   ):
    for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     __a :  Optional[Any]						=  TFLayoutLMModel.from_pretrained(snake_case_   )
     self.assertIsNotNone(snake_case_   )







   @unittest.skip('''Onnx compliancy broke with TF 2.10'''   )
   def       lowerCAmelCase			(self :					Union[str, Any]   ):
    pass





def    __UpperCamelCase     (				):
 # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
 # fmt: off
 __a :  List[str]						=  tf.convert_to_tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]  )  # noqa: E231
 __a :  Union[str, Any]						=  tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]  )  # noqa: E231
 __a :  str						=  tf.convert_to_tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]  )  # noqa: E231
 __a :  Any						=  tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]  )  # noqa: E231
 # these are sequence labels (i.e. at the token level)
 __a :  str						=  tf.convert_to_tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]  )  # noqa: E231
 # fmt: on

 return input_ids, attention_mask, bbox, token_type_ids, labels



@require_tf
class 		UpperCamelCase__  (       unittest.TestCase    ):
   @slow
   def       lowerCAmelCase			(self :					int   ):
    __a :  Tuple						=  TFLayoutLMModel.from_pretrained('''microsoft/layoutlm-base-uncased'''   )

    __a				,       __a				,       __a				,       __a				,       __a :  Any						=  prepare_layoutlm_batch_inputs()

    # forward pass
    __a :  int						=  model(input_ids=snake_case_					,				bbox=snake_case_					,				attention_mask=snake_case_					,				token_type_ids=snake_case_   )

    # test the sequence output on [0, :3, :3]
    __a :  Optional[Any]						=  tf.convert_to_tensor(
        [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]					,				)

    self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]					,				snake_case_					,				atol=1E-3   )   )

    # test the pooled output on [1, :3]
    __a :  int						=  tf.convert_to_tensor([-0.6580, -0.0214, 0.8552]   )

    self.assertTrue(np.allclose(outputs.pooler_output[1, :3]					,				snake_case_					,				atol=1E-3   )   )
   @slow
   def       lowerCAmelCase			(self :					int   ):
    # initialize model with randomly initialized sequence classification head
    __a :  int						=  TFLayoutLMForSequenceClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''					,				num_labels=2   )

    __a				,       __a				,       __a				,       __a				,       __a :  str						=  prepare_layoutlm_batch_inputs()

    # forward pass
    __a :  Union[str, Any]						=  model(
        input_ids=snake_case_					,				bbox=snake_case_					,				attention_mask=snake_case_					,				token_type_ids=snake_case_					,				labels=tf.convert_to_tensor([1, 1]   )					,				)

    # test whether we get a loss as a scalar
    __a :  Tuple						=  outputs.loss
    __a :  Dict						=  (2,)
    self.assertEqual(loss.shape					,				snake_case_   )

    # test the shape of the logits
    __a :  Dict						=  outputs.logits
    __a :  List[str]						=  (2, 2)
    self.assertEqual(logits.shape					,				snake_case_   )
   @slow
   def       lowerCAmelCase			(self :					str   ):
    # initialize model with randomly initialized token classification head
    __a :  Union[str, Any]						=  TFLayoutLMForTokenClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''					,				num_labels=1_3   )

    __a				,       __a				,       __a				,       __a				,       __a :  Optional[int]						=  prepare_layoutlm_batch_inputs()

    # forward pass
    __a :  Optional[int]						=  model(
        input_ids=snake_case_					,				bbox=snake_case_					,				attention_mask=snake_case_					,				token_type_ids=snake_case_					,				labels=snake_case_   )

    # test the shape of the logits
    __a :  str						=  outputs.logits
    __a :  List[str]						=  tf.convert_to_tensor((2, 2_5, 1_3)   )
    self.assertEqual(logits.shape					,				snake_case_   )







   @slow
   def       lowerCAmelCase			(self :					Any   ):
    # initialize model with randomly initialized token classification head
    __a :  Union[str, Any]						=  TFLayoutLMForQuestionAnswering.from_pretrained('''microsoft/layoutlm-base-uncased'''   )

    __a				,       __a				,       __a				,       __a				,       __a :  Dict						=  prepare_layoutlm_batch_inputs()

    # forward pass
    __a :  str						=  model(input_ids=snake_case_					,				bbox=snake_case_					,				attention_mask=snake_case_					,				token_type_ids=snake_case_   )

    # test the shape of the logits
    __a :  Optional[Any]						=  tf.convert_to_tensor((2, 2_5)   )
    self.assertEqual(outputs.start_logits.shape					,				snake_case_   )
    self.assertEqual(outputs.end_logits.shape					,				snake_case_   )


from typing import TYPE_CHECKING

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


lowercase__       ={
    'configuration_roformer': ['ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'RoFormerConfig', 'RoFormerOnnxConfig'],
    'tokenization_roformer': ['RoFormerTokenizer'],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase__       =['RoFormerTokenizerFast']

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase__       =[
          'ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
          'RoFormerForCausalLM',
          'RoFormerForMaskedLM',
          'RoFormerForMultipleChoice',
          'RoFormerForQuestionAnswering',
          'RoFormerForSequenceClassification',
          'RoFormerForTokenClassification',
          'RoFormerLayer',
          'RoFormerModel',
          'RoFormerPreTrainedModel',
          'load_tf_weights_in_roformer',
      ]


try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase__       =[
          'TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TFRoFormerForCausalLM',
          'TFRoFormerForMaskedLM',
          'TFRoFormerForMultipleChoice',
          'TFRoFormerForQuestionAnswering',
          'TFRoFormerForSequenceClassification',
          'TFRoFormerForTokenClassification',
          'TFRoFormerLayer',
          'TFRoFormerModel',
          'TFRoFormerPreTrainedModel',
      ]


try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase__       =[
          'FLAX_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
          'FlaxRoFormerForMaskedLM',
          'FlaxRoFormerForMultipleChoice',
          'FlaxRoFormerForQuestionAnswering',
          'FlaxRoFormerForSequenceClassification',
          'FlaxRoFormerForTokenClassification',
          'FlaxRoFormerModel',
          'FlaxRoFormerPreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_roformer import ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, RoFormerConfig, RoFormerOnnxConfig
      from .tokenization_roformer import RoFormerTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_roformer_fast import RoFormerTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_roformer import (
                ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                RoFormerForCausalLM,
                RoFormerForMaskedLM,
                RoFormerForMultipleChoice,
                RoFormerForQuestionAnswering,
                RoFormerForSequenceClassification,
                RoFormerForTokenClassification,
                RoFormerLayer,
                RoFormerModel,
                RoFormerPreTrainedModel,
                load_tf_weights_in_roformer,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_roformer import (
                TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFRoFormerForCausalLM,
                TFRoFormerForMaskedLM,
                TFRoFormerForMultipleChoice,
                TFRoFormerForQuestionAnswering,
                TFRoFormerForSequenceClassification,
                TFRoFormerForTokenClassification,
                TFRoFormerLayer,
                TFRoFormerModel,
                TFRoFormerPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_roformer import (
                FLAX_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                FlaxRoFormerForMaskedLM,
                FlaxRoFormerForMultipleChoice,
                FlaxRoFormerForQuestionAnswering,
                FlaxRoFormerForSequenceClassification,
                FlaxRoFormerForTokenClassification,
                FlaxRoFormerModel,
                FlaxRoFormerPreTrainedModel,
            )


else:
      import sys

      lowercase__       =_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
