import unittest

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

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 (
         RemBertConfig,
         RemBertForCausalLM,
         RemBertForMaskedLM,
         RemBertForMultipleChoice,
         RemBertForQuestionAnswering,
         RemBertForSequenceClassification,
         RemBertForTokenClassification,
         RemBertModel,
     )
     from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST

class   _lowercase:



   """simple docstring"""





   def __init__(							self:    List[Any]			,a:    Optional[int]			,a:    List[str]=13			,a:    Optional[int]=7			,a:    Optional[Any]=True			,a:    List[Any]=True			,a:    List[str]=True			,a:    Tuple=True			,a:    List[Any]=99			,a:    Optional[int]=32			,a:    Union[str, Any]=18			,a:    Union[str, Any]=43			,a:    List[str]=5			,a:    str=4			,a:    int=37			,a:    Tuple="gelu"			,a:    Optional[int]=0.1			,a:    Tuple=0.1			,a:    List[Any]=512			,a:    Any=16			,a:    int=2			,a:    Dict=0.02			,a:    Optional[int]=3			,a:    int=4			,a:    List[str]=None			,):
    __UpperCAmelCase         =					parent
    __UpperCAmelCase         =					batch_size
    __UpperCAmelCase         =					seq_length
    __UpperCAmelCase         =					is_training
    __UpperCAmelCase         =					use_input_mask
    __UpperCAmelCase         =					use_token_type_ids
    __UpperCAmelCase         =					use_labels
    __UpperCAmelCase         =					vocab_size
    __UpperCAmelCase         =					hidden_size
    __UpperCAmelCase         =					input_embedding_size
    __UpperCAmelCase         =					output_embedding_size
    __UpperCAmelCase         =					num_hidden_layers
    __UpperCAmelCase         =					num_attention_heads
    __UpperCAmelCase         =					intermediate_size
    __UpperCAmelCase         =					hidden_act
    __UpperCAmelCase         =					hidden_dropout_prob
    __UpperCAmelCase         =					attention_probs_dropout_prob
    __UpperCAmelCase         =					max_position_embeddings
    __UpperCAmelCase         =					type_vocab_size
    __UpperCAmelCase         =					type_sequence_label_size
    __UpperCAmelCase         =					initializer_range
    __UpperCAmelCase         =					num_labels
    __UpperCAmelCase         =					num_choices
    __UpperCAmelCase         =					scope





   def 			snake_case	(							self:    Union[str, Any]	):
    __UpperCAmelCase         =					ids_tensor([self.batch_size, self.seq_length]			,self.vocab_size	)

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

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

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

    __UpperCAmelCase         =					RemBertConfig(
        vocab_size=self.vocab_size			,hidden_size=self.hidden_size			,input_embedding_size=self.input_embedding_size			,output_embedding_size=self.output_embedding_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=__SCREAMING_SNAKE_CASE			,initializer_range=self.initializer_range			,)

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





   def 			snake_case	(							self:    List[Any]	):
    (
        (
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			   
    )         =					self.prepare_config_and_inputs()

    __UpperCAmelCase         =					True
    __UpperCAmelCase         =					floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
    __UpperCAmelCase         =					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 			snake_case	(							self:    Dict			,a:    Any			,a:    Union[str, Any]			,a:    Any			,a:    Optional[Any]			,a:    List[Any]			,a:    Optional[int]			,a:    Dict	):
    __UpperCAmelCase         =					RemBertModel(config=__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()
    __UpperCAmelCase         =					model(__SCREAMING_SNAKE_CASE			,attention_mask=__SCREAMING_SNAKE_CASE			,token_type_ids=__SCREAMING_SNAKE_CASE	)
    __UpperCAmelCase         =					model(__SCREAMING_SNAKE_CASE			,token_type_ids=__SCREAMING_SNAKE_CASE	)
    __UpperCAmelCase         =					model(__SCREAMING_SNAKE_CASE	)
    self.parent.assertEqual(result.last_hidden_state.shape			,(self.batch_size, self.seq_length, self.hidden_size)	)





   def 			snake_case	(							self:    List[str]			,a:    int			,a:    Dict			,a:    Optional[Any]			,a:    Optional[int]			,a:    Tuple			,a:    Tuple			,a:    Tuple			,a:    Optional[int]			,a:    Union[str, Any]			,):
    __UpperCAmelCase         =					True
    __UpperCAmelCase         =					RemBertModel(__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()
    __UpperCAmelCase         =					model(
        __SCREAMING_SNAKE_CASE			,attention_mask=__SCREAMING_SNAKE_CASE			,token_type_ids=__SCREAMING_SNAKE_CASE			,encoder_hidden_states=__SCREAMING_SNAKE_CASE			,encoder_attention_mask=__SCREAMING_SNAKE_CASE			,)
    __UpperCAmelCase         =					model(
        __SCREAMING_SNAKE_CASE			,attention_mask=__SCREAMING_SNAKE_CASE			,token_type_ids=__SCREAMING_SNAKE_CASE			,encoder_hidden_states=__SCREAMING_SNAKE_CASE			,)
    __UpperCAmelCase         =					model(__SCREAMING_SNAKE_CASE			,attention_mask=__SCREAMING_SNAKE_CASE			,token_type_ids=__SCREAMING_SNAKE_CASE	)
    self.parent.assertEqual(result.last_hidden_state.shape			,(self.batch_size, self.seq_length, self.hidden_size)	)





   def 			snake_case	(							self:    Any			,a:    str			,a:    Any			,a:    int			,a:    int			,a:    Dict			,a:    Tuple			,a:    Optional[int]			,a:    List[Any]			,a:    int			,):
    __UpperCAmelCase         =					RemBertForCausalLM(config=__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()
    __UpperCAmelCase         =					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.seq_length, self.vocab_size)	)





   def 			snake_case	(							self:    Union[str, Any]			,a:    Union[str, Any]			,a:    Dict			,a:    Optional[Any]			,a:    List[str]			,a:    Any			,a:    Any			,a:    str	):
    __UpperCAmelCase         =					RemBertForMaskedLM(config=__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()
    __UpperCAmelCase         =					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.seq_length, self.vocab_size)	)





   def 			snake_case	(							self:    Any			,a:    List[Any]			,a:    int			,a:    Optional[Any]			,a:    Optional[Any]			,a:    Union[str, Any]			,a:    List[str]			,a:    Tuple			,a:    List[str]			,a:    str			,):
    __UpperCAmelCase         =					True
    __UpperCAmelCase         =					True
    __UpperCAmelCase         =					RemBertForCausalLM(config=__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()

    # first forward pass
    __UpperCAmelCase         =					model(
        __SCREAMING_SNAKE_CASE			,attention_mask=__SCREAMING_SNAKE_CASE			,encoder_hidden_states=__SCREAMING_SNAKE_CASE			,encoder_attention_mask=__SCREAMING_SNAKE_CASE			,use_cache=__SCREAMING_SNAKE_CASE			,)
    __UpperCAmelCase         =					outputs.past_key_values

    # create hypothetical multiple next token and extent to next_input_ids
    __UpperCAmelCase         =					ids_tensor((self.batch_size, 3)			,config.vocab_size	)
    __UpperCAmelCase         =					ids_tensor((self.batch_size, 3)			,vocab_size=2	)

    # append to next input_ids and
    __UpperCAmelCase         =					torch.cat([input_ids, next_tokens]			,dim=-1	)
    __UpperCAmelCase         =					torch.cat([input_mask, next_mask]			,dim=-1	)

    __UpperCAmelCase         =					model(
        __SCREAMING_SNAKE_CASE			,attention_mask=__SCREAMING_SNAKE_CASE			,encoder_hidden_states=__SCREAMING_SNAKE_CASE			,encoder_attention_mask=__SCREAMING_SNAKE_CASE			,output_hidden_states=__SCREAMING_SNAKE_CASE			,)['hidden_states'][0]
    __UpperCAmelCase         =					model(
        __SCREAMING_SNAKE_CASE			,attention_mask=__SCREAMING_SNAKE_CASE			,encoder_hidden_states=__SCREAMING_SNAKE_CASE			,encoder_attention_mask=__SCREAMING_SNAKE_CASE			,past_key_values=__SCREAMING_SNAKE_CASE			,output_hidden_states=__SCREAMING_SNAKE_CASE			,)['hidden_states'][0]

    # select random slice
    __UpperCAmelCase         =					ids_tensor((1,)			,output_from_past.shape[-1]	).item()
    __UpperCAmelCase         =					output_from_no_past[:, -3:, random_slice_idx].detach()
    __UpperCAmelCase         =					output_from_past[:, :, random_slice_idx].detach()

    self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]	)

    # test that outputs are equal for slice
    self.parent.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE			,__SCREAMING_SNAKE_CASE			,atol=1e-3	)	)





   def 			snake_case	(							self:    List[Any]			,a:    Optional[int]			,a:    str			,a:    Optional[int]			,a:    int			,a:    Dict			,a:    Tuple			,a:    Optional[Any]	):
    __UpperCAmelCase         =					RemBertForQuestionAnswering(config=__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()
    __UpperCAmelCase         =					model(
        __SCREAMING_SNAKE_CASE			,attention_mask=__SCREAMING_SNAKE_CASE			,token_type_ids=__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 			snake_case	(							self:    Optional[int]			,a:    int			,a:    Dict			,a:    Dict			,a:    Union[str, Any]			,a:    Optional[Any]			,a:    Optional[int]			,a:    Dict	):
    __UpperCAmelCase         =					self.num_labels
    __UpperCAmelCase         =					RemBertForSequenceClassification(__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()
    __UpperCAmelCase         =					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_labels)	)





   def 			snake_case	(							self:    List[Any]			,a:    Any			,a:    Any			,a:    Union[str, Any]			,a:    Any			,a:    List[str]			,a:    Tuple			,a:    List[str]	):
    __UpperCAmelCase         =					self.num_labels
    __UpperCAmelCase         =					RemBertForTokenClassification(config=__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()
    __UpperCAmelCase         =					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.seq_length, self.num_labels)	)





   def 			snake_case	(							self:    List[str]			,a:    str			,a:    str			,a:    Optional[int]			,a:    Any			,a:    str			,a:    Union[str, Any]			,a:    Optional[Any]	):
    __UpperCAmelCase         =					self.num_choices
    __UpperCAmelCase         =					RemBertForMultipleChoice(config=__SCREAMING_SNAKE_CASE	)
    model.to(__SCREAMING_SNAKE_CASE	)
    model.eval()
    __UpperCAmelCase         =					input_ids.unsqueeze(1	).expand(-1			,self.num_choices			,-1	).contiguous()
    __UpperCAmelCase         =					token_type_ids.unsqueeze(1	).expand(-1			,self.num_choices			,-1	).contiguous()
    __UpperCAmelCase         =					input_mask.unsqueeze(1	).expand(-1			,self.num_choices			,-1	).contiguous()
    __UpperCAmelCase         =					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 			snake_case	(							self:    List[Any]	):
    __UpperCAmelCase         =					self.prepare_config_and_inputs()
    (
        (
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			   
    )         =					config_and_inputs
    __UpperCAmelCase         =					{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
    return config, inputs_dict




@require_torch
class   _lowercase(     UpperCamelCase_   ,UpperCamelCase_   ,unittest.TestCase				):



   """simple docstring"""





   __lowerCamelCase    =  (
       (
           RemBertModel,
           RemBertForMaskedLM,
           RemBertForCausalLM,
           RemBertForMultipleChoice,
           RemBertForQuestionAnswering,
           RemBertForSequenceClassification,
           RemBertForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   __lowerCamelCase    =  (RemBertForCausalLM,) if is_torch_available() else ()
   __lowerCamelCase    =  (
       {
           """feature-extraction""": RemBertModel,
           """fill-mask""": RemBertForMaskedLM,
           """question-answering""": RemBertForQuestionAnswering,
           """text-classification""": RemBertForSequenceClassification,
           """text-generation""": RemBertForCausalLM,
           """token-classification""": RemBertForTokenClassification,
           """zero-shot""": RemBertForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )





   def 			snake_case	(							self:    Optional[Any]	):
    __UpperCAmelCase         =					RemBertModelTester(self	)
    __UpperCAmelCase         =					ConfigTester(self			,config_class=__SCREAMING_SNAKE_CASE			,hidden_size=37	)





   def 			snake_case	(							self:    Dict	):
    self.config_tester.run_common_tests()





   def 			snake_case	(							self:    List[str]	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    Dict	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
    for type in ["absolute", "relative_key", "relative_key_query"]:
     __UpperCAmelCase         =					type
     self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    str	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    List[str]	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    Dict	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs_for_decoder()
    self.model_tester.create_and_check_decoder_model_past_large_inputs(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    Dict	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    Union[str, Any]	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    Optional[int]	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    List[Any]	):
    __UpperCAmelCase         =					self.model_tester.prepare_config_and_inputs_for_decoder()
    self.model_tester.create_and_check_model_as_decoder(*__SCREAMING_SNAKE_CASE	)





   def 			snake_case	(							self:    List[str]	):
    # This regression test was failing with PyTorch < 1.3
    (
        (
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			(
        __UpperCAmelCase   
    )  ,			   
    )         =					self.model_tester.prepare_config_and_inputs_for_decoder()

    __UpperCAmelCase         =					None

    self.model_tester.create_and_check_model_as_decoder(
        __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			,)





   @slow
   def 			snake_case	(							self:    Any	):
    for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     __UpperCAmelCase         =					RemBertModel.from_pretrained(__SCREAMING_SNAKE_CASE	)
     self.assertIsNotNone(__SCREAMING_SNAKE_CASE	)




@require_torch
class   _lowercase(     unittest.TestCase				):



   """simple docstring"""





   @slow
   def 			snake_case	(							self:    Union[str, Any]	):
    # Test exact values at the last hidden layer
    __UpperCAmelCase         =					RemBertModel.from_pretrained('google/rembert'	)
    __UpperCAmelCase         =					torch.tensor([[312, 56498, 313, 2125, 313]]	)
    __UpperCAmelCase         =					torch.tensor([[0, 0, 0, 1, 1]]	)
    with torch.no_grad():
     __UpperCAmelCase         =					model(__SCREAMING_SNAKE_CASE			,token_type_ids=__SCREAMING_SNAKE_CASE			,output_hidden_states=__SCREAMING_SNAKE_CASE	)

    __UpperCAmelCase         =					1152

    __UpperCAmelCase         =					torch.Size((1, 5, hidden_size)	)
    self.assertEqual(output['last_hidden_state'].shape			,__SCREAMING_SNAKE_CASE	)

    __UpperCAmelCase         =					torch.tensor(
        [
            [
                [0.0754, -0.2022, 0.1904],
                [-0.3354, -0.3692, -0.4791],
                [-0.2314, -0.6729, -0.0749],
                [-0.0396, -0.3105, -0.4234],
                [-0.1571, -0.0525, 0.5353],
            ]
        ]	)

    # Running on the original tf implementation gives slightly different results here.
    # Not clear why this variations is present
    # TODO: Find reason for discrepancy
    # expected_original_implementation = [[
    #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
    #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
    #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
    #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
    #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
    # ]]

    self.assertTrue(torch.allclose(output['last_hidden_state'][:, :, :3]			,__SCREAMING_SNAKE_CASE			,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				:		Dict       			=		{
    'configuration_marian': ['MARIAN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MarianConfig', 'MarianOnnxConfig'],
}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase				:		Optional[int]       			=		['MarianTokenizer']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase				:		Dict       			=		[
         'MARIAN_PRETRAINED_MODEL_ARCHIVE_LIST',
         'MarianForCausalLM',
         'MarianModel',
         'MarianMTModel',
         'MarianPreTrainedModel',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase				:		Dict       			=		['TFMarianModel', 'TFMarianMTModel', 'TFMarianPreTrainedModel']

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase				:		Any       			=		['FlaxMarianModel', 'FlaxMarianMTModel', 'FlaxMarianPreTrainedModel']

if TYPE_CHECKING:
     from .configuration_marian import MARIAN_PRETRAINED_CONFIG_ARCHIVE_MAP, MarianConfig, MarianOnnxConfig

     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_marian import MarianTokenizer

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_marian import (
              MARIAN_PRETRAINED_MODEL_ARCHIVE_LIST,
              MarianForCausalLM,
              MarianModel,
              MarianMTModel,
              MarianPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_marian import TFMarianModel, TFMarianMTModel, TFMarianPreTrainedModel

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_marian import FlaxMarianModel, FlaxMarianMTModel, FlaxMarianPreTrainedModel

else:
     import sys

     _UpperCamelCase				:		List[Any]       			=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



