
'''simple docstring'''


import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
   from transformers import (
       FlaxBertModel,
       FlaxCLIPVisionModel,
       FlaxVisionTextDualEncoderModel,
       FlaxViTModel,
       VisionTextDualEncoderConfig,
       VisionTextDualEncoderProcessor,
   )
   from transformers.modeling_flax_pytorch_utils import (
       convert_pytorch_state_dict_to_flax,
       load_flax_weights_in_pytorch_model,
   )


if is_torch_available():
   import torch

   from transformers import VisionTextDualEncoderModel

if is_vision_available():
   from PIL import Image



def  __snake_case     (    _UpperCAmelCase					:       Dict):
   if isinstance(_UpperCAmelCase,      collections.abc.Iterable):
      return x
   return (x, x)


@require_flax
class 						lowercase__	:






   '''simple docstring'''







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      pass







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      pass







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      pass







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  np.abs((a - b)   ).max()
      self.assertLessEqual(lowerCamelCase__ ,   lowerCamelCase__ ,   f'Difference between torch and flax is {diff} (>= {tol}).'   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__=None ,   **lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__ ,   lowerCamelCase__   )

      UpperCamelCase       =  FlaxVisionTextDualEncoderModel(lowerCamelCase__   )

      UpperCamelCase       =  model(input_ids=lowerCamelCase__ ,   pixel_values=lowerCamelCase__ ,   attention_mask=lowerCamelCase__   )

      self.assertEqual(output['''text_embeds'''].shape ,   (input_ids.shape[0], config.projection_dim)   )
      self.assertEqual(output['''image_embeds'''].shape ,   (pixel_values.shape[0], config.projection_dim)   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__=None ,   **lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase     , UpperCamelCase       =  self.get_vision_text_model(lowerCamelCase__ ,   lowerCamelCase__   )
      UpperCamelCase       =  {'''vision_model''': vision_model, '''text_model''': text_model}
      UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__   )

      UpperCamelCase       =  model(input_ids=lowerCamelCase__ ,   pixel_values=lowerCamelCase__ ,   attention_mask=lowerCamelCase__   )

      self.assertEqual(output['''text_embeds'''].shape ,   (input_ids.shape[0], model.config.projection_dim)   )
      self.assertEqual(output['''image_embeds'''].shape ,   (pixel_values.shape[0], model.config.projection_dim)   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__=None ,   **lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase     , UpperCamelCase       =  self.get_vision_text_model(lowerCamelCase__ ,   lowerCamelCase__   )
      UpperCamelCase       =  {'''vision_model''': vision_model, '''text_model''': text_model}
      UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__   )

      UpperCamelCase       =  model(input_ids=lowerCamelCase__ ,   pixel_values=lowerCamelCase__ ,   attention_mask=lowerCamelCase__   )
      UpperCamelCase       =  output[0]

      with tempfile.TemporaryDirectory() as tmpdirname:
         model.save_pretrained(lowerCamelCase__   )
         UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__   )

         UpperCamelCase       =  model(input_ids=lowerCamelCase__ ,   pixel_values=lowerCamelCase__ ,   attention_mask=lowerCamelCase__   )
         UpperCamelCase       =  after_output[0]
         UpperCamelCase       =  np.amax(np.abs(out_a - out_a   )   )
         self.assertLessEqual(lowerCamelCase__ ,   1e-3   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__=None ,   **lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase     , UpperCamelCase       =  self.get_vision_text_model(lowerCamelCase__ ,   lowerCamelCase__   )
      UpperCamelCase       =  {'''vision_model''': vision_model, '''text_model''': text_model}
      UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__   )

      UpperCamelCase       =  model(
          input_ids=lowerCamelCase__ ,   pixel_values=lowerCamelCase__ ,   attention_mask=lowerCamelCase__ ,   output_attentions=lowerCamelCase__   )

      UpperCamelCase       =  output.vision_model_output.attentions
      self.assertEqual(len(lowerCamelCase__   ) ,   vision_config.num_hidden_layers   )

      # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
      UpperCamelCase       =  to_atuple(vision_model.config.image_size   )
      UpperCamelCase       =  to_atuple(vision_model.config.patch_size   )
      UpperCamelCase       =  (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
      UpperCamelCase       =  num_patches + 1
      self.assertEqual(vision_attentions[0].shape[-3:] ,   (vision_config.num_attention_heads, seq_len, seq_len)   )

      UpperCamelCase       =  output.text_model_output.attentions
      self.assertEqual(len(lowerCamelCase__   ) ,   text_config.num_hidden_layers   )

      self.assertEqual(
          text_attentions[0].shape[-3:] ,   (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]) ,   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      pt_model.to(lowerCamelCase__   )
      pt_model.eval()

      # prepare inputs
      UpperCamelCase       =  inputs_dict
      UpperCamelCase       =  {k: torch.tensor(v.tolist()   ) for k, v in flax_inputs.items()}

      with torch.no_grad():
         UpperCamelCase       =  pt_model(**lowerCamelCase__   ).to_tuple()

      UpperCamelCase       =  fx_model(**lowerCamelCase__   ).to_tuple()
      self.assertEqual(len(lowerCamelCase__   ) ,   len(lowerCamelCase__   ) ,   '''Output lengths differ between Flax and PyTorch'''   )
      for fx_output, pt_output in zip(fx_outputs[:4] ,   pt_outputs[:4]   ):
         self.assert_almost_equals(lowerCamelCase__ ,   pt_output.numpy() ,   4e-2   )

      # PT -> Flax
      with tempfile.TemporaryDirectory() as tmpdirname:
         pt_model.save_pretrained(lowerCamelCase__   )
         UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__ ,   from_pt=lowerCamelCase__   )

      UpperCamelCase       =  fx_model_loaded(**lowerCamelCase__   ).to_tuple()
      self.assertEqual(len(lowerCamelCase__   ) ,   len(lowerCamelCase__   ) ,   '''Output lengths differ between Flax and PyTorch'''   )
      for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4] ,   pt_outputs[:4]   ):
         self.assert_almost_equals(lowerCamelCase__ ,   pt_output.numpy() ,   4e-2   )

      # Flax -> PT
      with tempfile.TemporaryDirectory() as tmpdirname:
         fx_model.save_pretrained(lowerCamelCase__   )
         UpperCamelCase       =  VisionTextDualEncoderModel.from_pretrained(lowerCamelCase__ ,   from_flax=lowerCamelCase__   )

      pt_model_loaded.to(lowerCamelCase__   )
      pt_model_loaded.eval()

      with torch.no_grad():
         UpperCamelCase       =  pt_model_loaded(**lowerCamelCase__   ).to_tuple()

      self.assertEqual(len(lowerCamelCase__   ) ,   len(lowerCamelCase__   ) ,   '''Output lengths differ between Flax and PyTorch'''   )
      for fx_output, pt_output_loaded in zip(fx_outputs[:4] ,   pt_outputs_loaded[:4]   ):
         self.assert_almost_equals(lowerCamelCase__ ,   pt_output_loaded.numpy() ,   4e-2   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__ ,   lowerCamelCase__   )

      UpperCamelCase       =  VisionTextDualEncoderModel(lowerCamelCase__   )
      UpperCamelCase       =  FlaxVisionTextDualEncoderModel(lowerCamelCase__   )

      UpperCamelCase       =  convert_pytorch_state_dict_to_flax(pt_model.state_dict() ,   lowerCamelCase__   )
      UpperCamelCase       =  fx_state

      self.check_pt_flax_equivalence(lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__ ,   lowerCamelCase__   )

      UpperCamelCase       =  VisionTextDualEncoderModel(lowerCamelCase__   )
      UpperCamelCase       =  FlaxVisionTextDualEncoderModel(lowerCamelCase__   )

      UpperCamelCase       =  load_flax_weights_in_pytorch_model(lowerCamelCase__ ,   fx_model.params   )

      self.check_pt_flax_equivalence(lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.prepare_config_and_inputs()
      self.check_model_from_pretrained_configs(**lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.prepare_config_and_inputs()
      self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.prepare_config_and_inputs()
      self.check_save_load(**lowerCamelCase__   )







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.prepare_config_and_inputs()
      self.check_vision_text_output_attention(**lowerCamelCase__   )







   @is_pt_flax_cross_test
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  self.prepare_config_and_inputs()
      UpperCamelCase       =  config_inputs_dict.pop('''vision_config'''   )
      UpperCamelCase       =  config_inputs_dict.pop('''text_config'''   )

      UpperCamelCase       =  config_inputs_dict

      self.check_equivalence_pt_to_flax(lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   )
      self.check_equivalence_flax_to_pt(lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   )







   @slow
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase     , UpperCamelCase       =  self.get_pretrained_model_and_inputs()

      UpperCamelCase       =  model_a(**lowerCamelCase__   )
      UpperCamelCase       =  outputs[0]

      with tempfile.TemporaryDirectory() as tmp_dirname:
         model_a.save_pretrained(lowerCamelCase__   )
         UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__   )

         UpperCamelCase       =  model_a(**lowerCamelCase__   )
         UpperCamelCase       =  after_outputs[0]
         UpperCamelCase       =  np.amax(np.abs(out_a - out_a   )   )
         self.assertLessEqual(lowerCamelCase__ ,   1e-5   )




@require_flax
class 						lowercase__	(  __UpperCAmelCase,					unittest.TestCase   ):






   '''simple docstring'''







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
          '''hf-internal-testing/tiny-random-vit''' ,   '''hf-internal-testing/tiny-bert''' ,   vision_from_pt=lowerCamelCase__ ,   text_from_pt=lowerCamelCase__ ,   )
      UpperCamelCase       =  1_3
      UpperCamelCase       =  floats_tensor(
          [
              batch_size,
              model.config.vision_config.num_channels,
              model.config.vision_config.image_size,
              model.config.vision_config.image_size,
          ]   )
      UpperCamelCase       =  ids_tensor([batch_size, 4] ,   model.config.text_config.vocab_size   )
      UpperCamelCase       =  random_attention_mask([batch_size, 4]   )
      UpperCamelCase       =  {'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

      return model, inputs







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  FlaxViTModel(lowerCamelCase__   )
      UpperCamelCase       =  FlaxBertModel(lowerCamelCase__   )
      return vision_model, text_model







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  FlaxViTModelTester(self   )
      UpperCamelCase       =  FlaxBertModelTester(self   )
      UpperCamelCase       =  vit_model_tester.prepare_config_and_inputs()
      UpperCamelCase       =  bert_model_tester.prepare_config_and_inputs()

      UpperCamelCase     , UpperCamelCase       =  vision_config_and_inputs

      UpperCamelCase     , UpperCamelCase     , UpperCamelCase     , UpperCamelCase       =  text_config_and_inputs

      # make sure that cross attention layers are added
      return {
          "text_config": text_config,
          "vision_config": vision_config,
          "pixel_values": pixel_values,
          "attention_mask": attention_mask,
          "input_ids": input_ids,
          "token_type_ids": token_type_ids,
      }




@require_torch
class 						lowercase__	(  __UpperCAmelCase,					unittest.TestCase   ):






   '''simple docstring'''







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
          '''hf-internal-testing/tiny-random-clip''' ,   '''hf-internal-testing/tiny-bert''' ,   vision_from_pt=lowerCamelCase__ ,   text_from_pt=lowerCamelCase__ ,   )
      UpperCamelCase       =  1_3
      UpperCamelCase       =  floats_tensor(
          [
              batch_size,
              model.config.vision_config.num_channels,
              model.config.vision_config.image_size,
              model.config.vision_config.image_size,
          ]   )
      UpperCamelCase       =  ids_tensor([batch_size, 4] ,   model.config.text_config.vocab_size   )
      UpperCamelCase       =  random_attention_mask([batch_size, 4]   )
      UpperCamelCase       =  {'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

      return model, inputs







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  FlaxCLIPVisionModel(lowerCamelCase__   )
      UpperCamelCase       =  FlaxBertModel(lowerCamelCase__   )
      return vision_model, text_model







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  FlaxCLIPVisionModelTester(self   )
      UpperCamelCase       =  FlaxBertModelTester(self   )
      UpperCamelCase       =  clip_model_tester.prepare_config_and_inputs()
      UpperCamelCase       =  bert_model_tester.prepare_config_and_inputs()

      UpperCamelCase     , UpperCamelCase       =  vision_config_and_inputs

      UpperCamelCase     , UpperCamelCase     , UpperCamelCase     , UpperCamelCase       =  text_config_and_inputs

      # make sure that cross attention layers are added
      return {
          "text_config": text_config,
          "vision_config": vision_config,
          "pixel_values": pixel_values,
          "attention_mask": attention_mask,
          "input_ids": input_ids,
          "token_type_ids": token_type_ids,
      }




@require_flax
@require_vision
class 						lowercase__	(  unittest.TestCase   ):






   '''simple docstring'''







   @slow
   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      UpperCamelCase       =  FlaxVisionTextDualEncoderModel.from_pretrained('''clip-italian/clip-italian''' ,   logit_scale_init_value=1.0   )
      UpperCamelCase       =  VisionTextDualEncoderProcessor.from_pretrained('''clip-italian/clip-italian'''   )

      UpperCamelCase       =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
      UpperCamelCase       =  processor(
          text=['''una foto di un gatto''', '''una foto di un cane'''] ,   images=lowerCamelCase__ ,   padding=lowerCamelCase__ ,   return_tensors='''np'''   )

      UpperCamelCase       =  model(**lowerCamelCase__   )

      # verify the logits
      self.assertEqual(outputs.logits_per_image.shape ,   (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])   )
      self.assertEqual(
          outputs.logits_per_text.shape ,   (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]) ,   )

      UpperCamelCase       =  np.array([[1.2284727, 0.3104122]]   )

      self.assertTrue(np.allclose(outputs.logits_per_image ,   lowerCamelCase__ ,   atol=1e-3   )   )







'''simple docstring'''


from typing import TYPE_CHECKING

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


snake_case_ :  List[Any]     =					{
    'configuration_data2vec_audio': ['DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Data2VecAudioConfig'],
    'configuration_data2vec_text': [
        'DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Data2VecTextConfig',
        'Data2VecTextOnnxConfig',
    ],
    'configuration_data2vec_vision': [
        'DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Data2VecVisionConfig',
        'Data2VecVisionOnnxConfig',
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   snake_case_ :  Union[str, Any]     =					[
       'DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST',
       'Data2VecAudioForAudioFrameClassification',
       'Data2VecAudioForCTC',
       'Data2VecAudioForSequenceClassification',
       'Data2VecAudioForXVector',
       'Data2VecAudioModel',
       'Data2VecAudioPreTrainedModel',
   ]
   snake_case_ :  str     =					[
       'DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'Data2VecTextForCausalLM',
       'Data2VecTextForMaskedLM',
       'Data2VecTextForMultipleChoice',
       'Data2VecTextForQuestionAnswering',
       'Data2VecTextForSequenceClassification',
       'Data2VecTextForTokenClassification',
       'Data2VecTextModel',
       'Data2VecTextPreTrainedModel',
   ]
   snake_case_ :  Optional[int]     =					[
       'DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST',
       'Data2VecVisionForImageClassification',
       'Data2VecVisionForMaskedImageModeling',
       'Data2VecVisionForSemanticSegmentation',
       'Data2VecVisionModel',
       'Data2VecVisionPreTrainedModel',
   ]

if is_tf_available():
   snake_case_ :  List[str]     =					[
       'TFData2VecVisionForImageClassification',
       'TFData2VecVisionForSemanticSegmentation',
       'TFData2VecVisionModel',
       'TFData2VecVisionPreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
   from .configuration_dataavec_text import (
       DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
       DataaVecTextConfig,
       DataaVecTextOnnxConfig,
   )
   from .configuration_dataavec_vision import (
       DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
       DataaVecVisionConfig,
       DataaVecVisionOnnxConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_dataavec_audio import (
          DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
          DataaVecAudioForAudioFrameClassification,
          DataaVecAudioForCTC,
          DataaVecAudioForSequenceClassification,
          DataaVecAudioForXVector,
          DataaVecAudioModel,
          DataaVecAudioPreTrainedModel,
      )
      from .modeling_dataavec_text import (
          DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
          DataaVecTextForCausalLM,
          DataaVecTextForMaskedLM,
          DataaVecTextForMultipleChoice,
          DataaVecTextForQuestionAnswering,
          DataaVecTextForSequenceClassification,
          DataaVecTextForTokenClassification,
          DataaVecTextModel,
          DataaVecTextPreTrainedModel,
      )
      from .modeling_dataavec_vision import (
          DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
          DataaVecVisionForImageClassification,
          DataaVecVisionForMaskedImageModeling,
          DataaVecVisionForSemanticSegmentation,
          DataaVecVisionModel,
          DataaVecVisionPreTrainedModel,
      )
   if is_tf_available():
      from .modeling_tf_dataavec_vision import (
          TFDataaVecVisionForImageClassification,
          TFDataaVecVisionForSemanticSegmentation,
          TFDataaVecVisionModel,
          TFDataaVecVisionPreTrainedModel,
      )

else:
   import sys

   snake_case_ :  int     =					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





