


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 				lowerCamelCase__       :





     def __init__(self		,					UpperCAmelCase		,					UpperCAmelCase=1_3		,					UpperCAmelCase=7		,					UpperCAmelCase=True		,					UpperCAmelCase=True		,					UpperCAmelCase=True		,					UpperCAmelCase=True		,					UpperCAmelCase=9_9		,					UpperCAmelCase=3_2		,					UpperCAmelCase=1_8		,					UpperCAmelCase=4_3		,					UpperCAmelCase=5		,					UpperCAmelCase=4		,					UpperCAmelCase=3_7		,					UpperCAmelCase="gelu"		,					UpperCAmelCase=0.1		,					UpperCAmelCase=0.1		,					UpperCAmelCase=5_1_2		,					UpperCAmelCase=1_6		,					UpperCAmelCase=2		,					UpperCAmelCase=0.02		,					UpperCAmelCase=3		,					UpperCAmelCase=4		,					UpperCAmelCase=None		,					)					->       Optional[int]:
      _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											=input_embedding_size
      _lowercase											=output_embedding_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 					__A (self	)					->       List[str]:
      _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											=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 					__A (self	)					->       Any:
      (
          (
          _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 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase	)					->       Optional[Any]:
      _lowercase											=RemBertModel(config=__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      model.eval()
      _lowercase											=model(__SCREAMING_SNAKE_CASE		,					attention_mask=__SCREAMING_SNAKE_CASE		,					token_type_ids=__SCREAMING_SNAKE_CASE	)
      _lowercase											=model(__SCREAMING_SNAKE_CASE		,					token_type_ids=__SCREAMING_SNAKE_CASE	)
      _lowercase											=model(__SCREAMING_SNAKE_CASE	)
      self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, self.seq_length, self.hidden_size)	)





     def 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					)					->       List[str]:
      _lowercase											=True
      _lowercase											=RemBertModel(__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      model.eval()
      _lowercase											=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		,					)
      _lowercase											=model(
          __SCREAMING_SNAKE_CASE		,					attention_mask=__SCREAMING_SNAKE_CASE		,					token_type_ids=__SCREAMING_SNAKE_CASE		,					encoder_hidden_states=__SCREAMING_SNAKE_CASE		,					)
      _lowercase											=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 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					)					->       Any:
      _lowercase											=RemBertForCausalLM(config=__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      model.eval()
      _lowercase											=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 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase	)					->       Optional[Any]:
      _lowercase											=RemBertForMaskedLM(config=__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      model.eval()
      _lowercase											=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 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					)					->       int:
      _lowercase											=True
      _lowercase											=True
      _lowercase											=RemBertForCausalLM(config=__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      model.eval()

      # first forward pass
      _lowercase											=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		,					)
      _lowercase											=outputs.past_key_values

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

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

      _lowercase											=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]
      _lowercase											=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
      _lowercase											=ids_tensor((1,)		,					output_from_past.shape[-1]	).item()
      _lowercase											=output_from_no_past[:, -3:, random_slice_idx].detach()
      _lowercase											=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 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase	)					->       Optional[Any]:
      _lowercase											=RemBertForQuestionAnswering(config=__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      model.eval()
      _lowercase											=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 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase	)					->       Optional[Any]:
      _lowercase											=self.num_labels
      _lowercase											=RemBertForSequenceClassification(__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      model.eval()
      _lowercase											=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 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase	)					->       Union[str, Any]:
      _lowercase											=self.num_labels
      _lowercase											=RemBertForTokenClassification(config=__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      model.eval()
      _lowercase											=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 					__A (self		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase	)					->       Optional[int]:
      _lowercase											=self.num_choices
      _lowercase											=RemBertForMultipleChoice(config=__SCREAMING_SNAKE_CASE	)
      model.to(__SCREAMING_SNAKE_CASE	)
      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(
          __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 					__A (self	)					->       Union[str, Any]:
      _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 				lowerCamelCase__       (	__lowerCAmelCase       ,							__lowerCAmelCase       ,							unittest.TestCase):
     SCREAMING_SNAKE_CASE__				      =      (
         (
             RemBertModel,
             RemBertForMaskedLM,
             RemBertForCausalLM,
             RemBertForMultipleChoice,
             RemBertForQuestionAnswering,
             RemBertForSequenceClassification,
             RemBertForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     SCREAMING_SNAKE_CASE__				      =      (RemBertForCausalLM,) if is_torch_available() else ()
     SCREAMING_SNAKE_CASE__				      =      (
         {
             '''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 					__A (self	)					->       Any:
      _lowercase											=RemBertModelTester(self	)
      _lowercase											=ConfigTester(self		,					config_class=__SCREAMING_SNAKE_CASE		,					hidden_size=3_7	)





     def 					__A (self	)					->       str:
      self.config_tester.run_common_tests()





     def 					__A (self	)					->       Union[str, Any]:
      _lowercase											=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       Optional[int]:
      _lowercase											=self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
       _lowercase											=type
       self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       Tuple:
      _lowercase											=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       Dict:
      _lowercase											=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       Optional[int]:
      _lowercase											=self.model_tester.prepare_config_and_inputs_for_decoder()
      self.model_tester.create_and_check_decoder_model_past_large_inputs(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       str:
      _lowercase											=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       Union[str, Any]:
      _lowercase											=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       Optional[Any]:
      _lowercase											=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       Dict:
      _lowercase											=self.model_tester.prepare_config_and_inputs_for_decoder()
      self.model_tester.create_and_check_model_as_decoder(*__SCREAMING_SNAKE_CASE	)





     def 					__A (self	)					->       int:
      (
          (
          _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(
          __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 					__A (self	)					->       int:




      for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       _lowercase											=RemBertModel.from_pretrained(__SCREAMING_SNAKE_CASE	)
       self.assertIsNotNone(__SCREAMING_SNAKE_CASE	)







@require_torch
class 				lowerCamelCase__       (	unittest.TestCase):





     @slow
     def 					__A (self	)					->       Any:
      _lowercase											=RemBertModel.from_pretrained('''google/rembert'''	)
      _lowercase											=torch.tensor([[3_1_2, 5_6_4_9_8, 3_1_3, 2_1_2_5, 3_1_3]]	)
      _lowercase											=torch.tensor([[0, 0, 0, 1, 1]]	)
      with torch.no_grad():
       _lowercase											=model(__SCREAMING_SNAKE_CASE		,					token_type_ids=__SCREAMING_SNAKE_CASE		,					output_hidden_states=__SCREAMING_SNAKE_CASE	)

      _lowercase											=1_1_5_2

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

      _lowercase											=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	)	)








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__            =							{'''configuration_visual_bert''': ['''VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''VisualBertConfig''']}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase__            =							[
      '''VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''VisualBertForMultipleChoice''',
      '''VisualBertForPreTraining''',
      '''VisualBertForQuestionAnswering''',
      '''VisualBertForRegionToPhraseAlignment''',
      '''VisualBertForVisualReasoning''',
      '''VisualBertLayer''',
      '''VisualBertModel''',
      '''VisualBertPreTrainedModel''',
  ]


if TYPE_CHECKING:
  from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_visual_bert import (
        VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        VisualBertForMultipleChoice,
        VisualBertForPreTraining,
        VisualBertForQuestionAnswering,
        VisualBertForRegionToPhraseAlignment,
        VisualBertForVisualReasoning,
        VisualBertLayer,
        VisualBertModel,
        VisualBertPreTrainedModel,
    )


else:
  import sys

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

