

import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch
       from torch import nn

       from transformers import (
           MODEL_MAPPING,
           BeitForImageClassification,
           BeitForMaskedImageModeling,
           BeitForSemanticSegmentation,
           BeitModel,
       )
       from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       import PIL
       from PIL import Image

       from transformers import BeitImageProcessor



class       __snake_case  :

  def __init__(					self						,		_A						,		_A=100						,		_A=13						,		_A=30						,		_A=2						,		_A=3						,		_A=True						,		_A=True						,		_A=32						,		_A=4						,		_A=4						,		_A=37						,		_A="gelu"						,		_A=0.1						,		_A=0.1						,		_A=10						,		_A=0.0_2						,		_A=3						,		_A=None						,		_A=[0, 1, 2, 3]						,		):
      SCREAMING_SNAKE_CASE_									=						parent
      SCREAMING_SNAKE_CASE_									=						100
      SCREAMING_SNAKE_CASE_									=						batch_size
      SCREAMING_SNAKE_CASE_									=						image_size
      SCREAMING_SNAKE_CASE_									=						patch_size
      SCREAMING_SNAKE_CASE_									=						num_channels
      SCREAMING_SNAKE_CASE_									=						is_training
      SCREAMING_SNAKE_CASE_									=						use_labels
      SCREAMING_SNAKE_CASE_									=						hidden_size
      SCREAMING_SNAKE_CASE_									=						num_hidden_layers
      SCREAMING_SNAKE_CASE_									=						num_attention_heads
      SCREAMING_SNAKE_CASE_									=						intermediate_size
      SCREAMING_SNAKE_CASE_									=						hidden_act
      SCREAMING_SNAKE_CASE_									=						hidden_dropout_prob
      SCREAMING_SNAKE_CASE_									=						attention_probs_dropout_prob
      SCREAMING_SNAKE_CASE_									=						type_sequence_label_size
      SCREAMING_SNAKE_CASE_									=						initializer_range
      SCREAMING_SNAKE_CASE_									=						scope
      SCREAMING_SNAKE_CASE_									=						out_indices
      SCREAMING_SNAKE_CASE_									=						num_labels

      # in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
      SCREAMING_SNAKE_CASE_									=						(image_size // patch_size) ** 2
      SCREAMING_SNAKE_CASE_									=						num_patches + 1

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

      SCREAMING_SNAKE_CASE_									=						None
      SCREAMING_SNAKE_CASE_									=						None
      if self.use_labels:
          SCREAMING_SNAKE_CASE_									=						ids_tensor([self.batch_size]						,		self.type_sequence_label_size)
          SCREAMING_SNAKE_CASE_									=						ids_tensor([self.batch_size, self.image_size, self.image_size]						,		self.num_labels)

      SCREAMING_SNAKE_CASE_									=						self.get_config()

      return config, pixel_values, labels, pixel_labels

  def 						lowerCAmelCase__     (					self):
      return BeitConfig(
          vocab_size=self.vocab_size						,		image_size=self.image_size						,		patch_size=self.patch_size						,		num_channels=self.num_channels						,		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						,		is_decoder=_A						,		initializer_range=self.initializer_range						,		out_indices=self.out_indices						,		)

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A):
      SCREAMING_SNAKE_CASE_									=						BeitModel(config=_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A)
      self.parent.assertEqual(result.last_hidden_state.shape						,		(self.batch_size, self.seq_length, self.hidden_size))

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A):
      SCREAMING_SNAKE_CASE_									=						BeitForMaskedImageModeling(config=_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A)
      self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.seq_length - 1, self.vocab_size))

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A):
      SCREAMING_SNAKE_CASE_									=						self.type_sequence_label_size
      SCREAMING_SNAKE_CASE_									=						BeitForImageClassification(_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A						,		labels=_A)
      self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.type_sequence_label_size))

      # test greyscale images
      SCREAMING_SNAKE_CASE_									=						1
      SCREAMING_SNAKE_CASE_									=						BeitForImageClassification(_A)
      model.to(_A)
      model.eval()

      SCREAMING_SNAKE_CASE_									=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
      SCREAMING_SNAKE_CASE_									=						model(_A						,		labels=_A)
      self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.type_sequence_label_size))

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A):
      SCREAMING_SNAKE_CASE_									=						self.num_labels
      SCREAMING_SNAKE_CASE_									=						BeitForSemanticSegmentation(_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A)
      self.parent.assertEqual(
          result.logits.shape						,		(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2))
      SCREAMING_SNAKE_CASE_									=						model(_A						,		labels=_A)
      self.parent.assertEqual(
          result.logits.shape						,		(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2))


  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.prepare_config_and_inputs()
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						config_and_inputs
      SCREAMING_SNAKE_CASE_									=						{'pixel_values': pixel_values}
      return config, inputs_dict






@require_torch
class       __snake_case  (    lowerCAmelCase__     , lowerCAmelCase__     , unittest.TestCase       ):
  __lowerCAmelCase     :	Union[str, Any]						 =  (
      (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
      if is_torch_available()
      else ()
  )
  __lowerCAmelCase     :	Union[str, Any]						 =  (
      {
          'feature-extraction': BeitModel,
          'image-classification': BeitForImageClassification,
          'image-segmentation': BeitForSemanticSegmentation,
      }
      if is_torch_available()
      else {}
  )

  __lowerCAmelCase     :	Union[str, Any]						 =  False
  __lowerCAmelCase     :	Dict						 =  False
  __lowerCAmelCase     :	int						 =  False

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						BeitModelTester(self)
      SCREAMING_SNAKE_CASE_									=						ConfigTester(self						,		config_class=_A						,		has_text_modality=_A						,		hidden_size=37)

  def 						lowerCAmelCase__     (					self):
      self.config_tester.run_common_tests()

  @unittest.skip(reason='BEiT does not use inputs_embeds')
  def 						lowerCAmelCase__     (					self):
      pass

  @require_torch_multi_gpu
  @unittest.skip(reason='BEiT has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`')
  def 						lowerCAmelCase__     (					self):
      pass

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          SCREAMING_SNAKE_CASE_									=						model_class(_A)
          self.assertIsInstance(model.get_input_embeddings()						,		(nn.Module))
          SCREAMING_SNAKE_CASE_									=						model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(_A						,		nn.Linear))

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          SCREAMING_SNAKE_CASE_									=						model_class(_A)
          SCREAMING_SNAKE_CASE_									=						inspect.signature(model.forward)
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          SCREAMING_SNAKE_CASE_									=						[*signature.parameters.keys()]

          SCREAMING_SNAKE_CASE_									=						['pixel_values']
          self.assertListEqual(arg_names[:1]						,		_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_semantic_segmentation(*_A)

  def 						lowerCAmelCase__     (					self):
      if not self.model_tester.is_training:
          return

      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()
      SCREAMING_SNAKE_CASE_									=						True

      for model_class in self.all_model_classes:
          # we don't test BeitForMaskedImageModeling
          if model_class in [*get_values(_A), BeitForMaskedImageModeling]:
              continue

          SCREAMING_SNAKE_CASE_									=						model_class(_A)
          model.to(_A)
          model.train()
          SCREAMING_SNAKE_CASE_									=						self._prepare_for_class(_A						,		_A						,		return_labels=_A)
          SCREAMING_SNAKE_CASE_									=						model(**_A).loss
          loss.backward()

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()
      if not self.model_tester.is_training:
          return

      SCREAMING_SNAKE_CASE_									=						False
      SCREAMING_SNAKE_CASE_									=						True

      for model_class in self.all_model_classes:
          # we don't test BeitForMaskedImageModeling
          if (
              model_class in [*get_values(_A), BeitForMaskedImageModeling]
              or not model_class.supports_gradient_checkpointing
          ):
              continue

          SCREAMING_SNAKE_CASE_									=						model_class(_A)
          model.gradient_checkpointing_enable()
          model.to(_A)
          model.train()
          SCREAMING_SNAKE_CASE_									=						self._prepare_for_class(_A						,		_A						,		return_labels=_A)
          SCREAMING_SNAKE_CASE_									=						model(**_A).loss
          loss.backward()

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()

      SCREAMING_SNAKE_CASE_									=						_config_zero_init(_A)
      for model_class in self.all_model_classes:
          SCREAMING_SNAKE_CASE_									=						model_class(config=_A)
          for name, param in model.named_parameters():
              # we skip lambda parameters as these require special initial values
              # determined by config.layer_scale_init_value
              if "lambda" in name:
                  continue
              if param.requires_grad:
                  self.assertIn(
                      ((param.data.mean() * 1E9).round() / 1E9).item()						,		[0.0, 1.0]						,		msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""						,		)


  @slow
  def 						lowerCAmelCase__     (					self):
      for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          SCREAMING_SNAKE_CASE_									=						BeitModel.from_pretrained(_A)
          self.assertIsNotNone(_A)






def 					_UpperCAmelCase       (  ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       )
    return image





@require_torch
@require_vision
class       __snake_case  (    unittest.TestCase       ):

  @cached_property
  def 						lowerCAmelCase__     (					self):
      return BeitImageProcessor.from_pretrained('microsoft/beit-base-patch16-224') if is_vision_available() else None

  @slow
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						BeitForMaskedImageModeling.from_pretrained('microsoft/beit-base-patch16-224-pt22k').to(_A)

      SCREAMING_SNAKE_CASE_									=						self.default_image_processor
      SCREAMING_SNAKE_CASE_									=						prepare_img()
      SCREAMING_SNAKE_CASE_									=						image_processor(images=_A						,		return_tensors='pt').pixel_values.to(_A)

      # prepare bool_masked_pos
      SCREAMING_SNAKE_CASE_									=						torch.ones((1, 196)						,		dtype=torch.bool).to(_A)

      # forward pass
      with torch.no_grad():
          SCREAMING_SNAKE_CASE_									=						model(pixel_values=_A						,		bool_masked_pos=_A)
      SCREAMING_SNAKE_CASE_									=						outputs.logits

      # verify the logits
      SCREAMING_SNAKE_CASE_									=						torch.Size((1, 196, 8192))
      self.assertEqual(logits.shape						,		_A)

      SCREAMING_SNAKE_CASE_									=						torch.tensor(
          [[-3.2_4_3_7, 0.5_0_7_2, -13.9174], [-3.2_4_5_6, 0.4_9_4_8, -13.9401], [-3.2_0_3_3, 0.5_1_2_1, -13.8550]]).to(_A)

      self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]						,		_A						,		atol=1E-2))

  @slow
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						BeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224').to(_A)

      SCREAMING_SNAKE_CASE_									=						self.default_image_processor
      SCREAMING_SNAKE_CASE_									=						prepare_img()
      SCREAMING_SNAKE_CASE_									=						image_processor(images=_A						,		return_tensors='pt').to(_A)

      # forward pass
      with torch.no_grad():
          SCREAMING_SNAKE_CASE_									=						model(**_A)
      SCREAMING_SNAKE_CASE_									=						outputs.logits

      # verify the logits
      SCREAMING_SNAKE_CASE_									=						torch.Size((1, 1000))
      self.assertEqual(logits.shape						,		_A)

      SCREAMING_SNAKE_CASE_									=						torch.tensor([-1.2_3_8_5, -1.0_9_8_7, -1.0_1_0_8]).to(_A)

      self.assertTrue(torch.allclose(logits[0, :3]						,		_A						,		atol=1E-4))

      SCREAMING_SNAKE_CASE_									=						281
      self.assertEqual(logits.argmax(-1).item()						,		_A)

  @slow
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						BeitForImageClassification.from_pretrained('microsoft/beit-large-patch16-224-pt22k-ft22k').to(
          _A)

      SCREAMING_SNAKE_CASE_									=						self.default_image_processor
      SCREAMING_SNAKE_CASE_									=						prepare_img()
      SCREAMING_SNAKE_CASE_									=						image_processor(images=_A						,		return_tensors='pt').to(_A)

      # forward pass
      with torch.no_grad():
          SCREAMING_SNAKE_CASE_									=						model(**_A)
      SCREAMING_SNAKE_CASE_									=						outputs.logits

      # verify the logits
      SCREAMING_SNAKE_CASE_									=						torch.Size((1, 21841))
      self.assertEqual(logits.shape						,		_A)

      SCREAMING_SNAKE_CASE_									=						torch.tensor([1.6_8_8_1, -0.2_7_8_7, 0.5_9_0_1]).to(_A)

      self.assertTrue(torch.allclose(logits[0, :3]						,		_A						,		atol=1E-4))

      SCREAMING_SNAKE_CASE_									=						2396
      self.assertEqual(logits.argmax(-1).item()						,		_A)

  @slow
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640')
      SCREAMING_SNAKE_CASE_									=						model.to(_A)

      SCREAMING_SNAKE_CASE_									=						BeitImageProcessor(do_resize=_A						,		size=640						,		do_center_crop=_A)

      SCREAMING_SNAKE_CASE_									=						load_dataset('hf-internal-testing/fixtures_ade20k'						,		split='test')
      SCREAMING_SNAKE_CASE_									=						Image.open(ds[0]['file'])
      SCREAMING_SNAKE_CASE_									=						image_processor(images=_A						,		return_tensors='pt').to(_A)

      # forward pass
      with torch.no_grad():
          SCREAMING_SNAKE_CASE_									=						model(**_A)
      SCREAMING_SNAKE_CASE_									=						outputs.logits

      # verify the logits
      SCREAMING_SNAKE_CASE_									=						torch.Size((1, 150, 160, 160))
      self.assertEqual(logits.shape						,		_A)

      SCREAMING_SNAKE_CASE_									=						version.parse(PIL.__version__) < version.parse('9.0.0')

      if is_pillow_less_than_a:
          SCREAMING_SNAKE_CASE_									=						torch.tensor(
              [
                  [[-4.9_2_2_5, -2.3_9_5_4, -3.0_5_2_2], [-2.8_8_2_2, -1.0_0_4_6, -1.7_5_6_1], [-2.9_5_4_9, -1.3_2_2_8, -2.1_3_4_7]],
                  [[-5.8_1_6_8, -3.4_1_2_9, -4.0_7_7_8], [-3.8_6_5_1, -2.2_2_1_4, -3.0_2_7_7], [-3.8_3_5_6, -2.4_6_4_3, -3.3_5_3_5]],
                  [[-0.0_0_7_8, 3.9_9_5_2, 4.0_7_5_4], [2.9_8_5_6, 4.6_9_4_4, 5.0_0_3_5], [3.2_4_1_3, 4.7_8_1_3, 4.9_9_6_9]],
              ]						,		device=_A						,		)
      else:
          SCREAMING_SNAKE_CASE_									=						torch.tensor(
              [
                  [[-4.8_9_6_0, -2.3_6_8_8, -3.0_3_5_5], [-2.8_4_7_8, -0.9_8_3_6, -1.7_4_1_8], [-2.9_4_4_9, -1.3_3_3_2, -2.1_4_5_6]],
                  [[-5.8_0_8_1, -3.4_1_2_4, -4.1_0_0_6], [-3.8_5_6_1, -2.2_0_8_1, -3.0_3_2_3], [-3.8_3_6_5, -2.4_6_0_1, -3.3_6_6_9]],
                  [[-0.0_3_0_9, 3.9_8_6_8, 4.0_5_4_0], [2.9_6_4_0, 4.6_8_7_7, 4.9_9_7_6], [3.2_0_8_1, 4.7_6_9_0, 4.9_9_4_2]],
              ]						,		device=_A						,		)

      self.assertTrue(torch.allclose(logits[0, :3, :3, :3]						,		_A						,		atol=1E-4))


  @slow
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640')
      SCREAMING_SNAKE_CASE_									=						model.to(_A)

      SCREAMING_SNAKE_CASE_									=						BeitImageProcessor(do_resize=_A						,		size=640						,		do_center_crop=_A)

      SCREAMING_SNAKE_CASE_									=						load_dataset('hf-internal-testing/fixtures_ade20k'						,		split='test')
      SCREAMING_SNAKE_CASE_									=						Image.open(ds[0]['file'])
      SCREAMING_SNAKE_CASE_									=						image_processor(images=_A						,		return_tensors='pt').to(_A)

      # forward pass
      with torch.no_grad():
          SCREAMING_SNAKE_CASE_									=						model(**_A)

      SCREAMING_SNAKE_CASE_									=						outputs.logits.detach().cpu()

      SCREAMING_SNAKE_CASE_									=						image_processor.post_process_semantic_segmentation(outputs=_A						,		target_sizes=[(500, 300)])
      SCREAMING_SNAKE_CASE_									=						torch.Size((500, 300))
      self.assertEqual(segmentation[0].shape						,		_A)

      SCREAMING_SNAKE_CASE_									=						image_processor.post_process_semantic_segmentation(outputs=_A)
      SCREAMING_SNAKE_CASE_									=						torch.Size((160, 160))
      self.assertEqual(segmentation[0].shape						,		_A)








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


UpperCamelCase__  :      Any			=    {
    "configuration_mvp": ["MVP_PRETRAINED_CONFIG_ARCHIVE_MAP", "MvpConfig", "MvpOnnxConfig"],
    "tokenization_mvp": ["MvpTokenizer"],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCamelCase__  :      Optional[int]			=    ["MvpTokenizerFast"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCamelCase__  :      str			=    [
           "MVP_PRETRAINED_MODEL_ARCHIVE_LIST",
           "MvpForCausalLM",
           "MvpForConditionalGeneration",
           "MvpForQuestionAnswering",
           "MvpForSequenceClassification",
           "MvpModel",
           "MvpPreTrainedModel",
       ]

if TYPE_CHECKING:
       from .configuration_mvp import MVP_PRETRAINED_CONFIG_ARCHIVE_MAP, MvpConfig, MvpOnnxConfig
       from .tokenization_mvp import MvpTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_mvp_fast import MvpTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_mvp import (
                  MVP_PRETRAINED_MODEL_ARCHIVE_LIST,
                  MvpForCausalLM,
                  MvpForConditionalGeneration,
                  MvpForQuestionAnswering,
                  MvpForSequenceClassification,
                  MvpModel,
                  MvpPreTrainedModel,
              )

else:
       import sys

       UpperCamelCase__  :      Dict			=    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


