


import unittest

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

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           FalconForCausalLM,
           FalconForQuestionAnswering,
           FalconForSequenceClassification,
           FalconForTokenClassification,
           FalconModel,
       )


class   a__	:

       def __init__(   self      :     Tuple      ,							lowerCamelCase_      :     Tuple      ,							lowerCamelCase_      :     Tuple=3      ,							lowerCamelCase_      :     str=7      ,							lowerCamelCase_      :     Optional[int]=True      ,							lowerCamelCase_      :     str=True      ,							lowerCamelCase_      :     Tuple=False      ,							lowerCamelCase_      :     Any=True      ,							lowerCamelCase_      :     Dict=9_9      ,							lowerCamelCase_      :     Tuple=3_2      ,							lowerCamelCase_      :     Optional[Any]=5      ,							lowerCamelCase_      :     int=4      ,							lowerCamelCase_      :     str=3_7      ,							lowerCamelCase_      :     Optional[Any]="gelu"      ,							lowerCamelCase_      :     List[Any]=0.1      ,							lowerCamelCase_      :     Optional[int]=0.1      ,							lowerCamelCase_      :     List[Any]=5_1_2      ,							lowerCamelCase_      :     str=1_6      ,							lowerCamelCase_      :     List[str]=2      ,							lowerCamelCase_      :     Optional[Any]=0.0_2      ,							lowerCamelCase_      :     Any=3      ,							lowerCamelCase_      :     List[str]=4      ,							lowerCamelCase_      :     str=None      ,							):
            a_    :     str										=    parent
            a_    :     List[Any]										=    batch_size
            a_    :     List[Any]										=    seq_length
            a_    :     str										=    is_training
            a_    :     Union[str, Any]										=    use_input_mask
            a_    :     Dict										=    use_token_type_ids
            a_    :     Optional[Any]										=    use_labels
            a_    :     Union[str, Any]										=    vocab_size
            a_    :     str										=    hidden_size
            a_    :     Union[str, Any]										=    num_hidden_layers
            a_    :     int										=    num_attention_heads
            a_    :     Optional[Any]										=    intermediate_size
            a_    :     str										=    hidden_act
            a_    :     Any										=    hidden_dropout_prob
            a_    :     Union[str, Any]										=    attention_probs_dropout_prob
            a_    :     Optional[Any]										=    max_position_embeddings
            a_    :     Optional[Any]										=    type_vocab_size
            a_    :     Tuple										=    type_sequence_label_size
            a_    :     Union[str, Any]										=    initializer_range
            a_    :     Optional[Any]										=    num_labels
            a_    :     str										=    num_choices
            a_    :     str										=    scope

       def 						UpperCAmelCase(   self      :     Optional[Any]    ):
            a_    :     Tuple										=    ids_tensor([self.batch_size, self.seq_length]      ,							self.vocab_size    )

            a_    :     Dict										=    None
            if self.use_input_mask:
                 a_    :     List[Any]										=    random_attention_mask([self.batch_size, self.seq_length]    )

            a_    :     str										=    None

            a_    :     Tuple										=    None
            a_    :     Dict										=    None
            a_    :     Union[str, Any]										=    None
            if self.use_labels:
                 a_    :     Any										=    ids_tensor([self.batch_size]      ,							self.type_sequence_label_size    )
                 a_    :     Any										=    ids_tensor([self.batch_size, self.seq_length]      ,							self.num_labels    )
                 a_    :     Dict										=    ids_tensor([self.batch_size]      ,							self.num_choices    )

            a_    :     List[str]										=    self.get_config()

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

       def 						UpperCAmelCase(   self      :     Union[str, Any]    ):
            return FalconConfig(
                vocab_size=self.vocab_size      ,							hidden_size=self.hidden_size      ,							num_hidden_layers=self.num_hidden_layers      ,							num_attention_heads=self.num_attention_heads      ,							intermediate_size=self.intermediate_size      ,							hidden_act=self.hidden_act      ,							hidden_dropout_prob=self.hidden_dropout_prob      ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,							max_position_embeddings=self.max_position_embeddings      ,							type_vocab_size=self.type_vocab_size      ,							is_decoder=lowerCamelCase_      ,							initializer_range=self.initializer_range      ,							pad_token_id=1      ,							new_decoder_architecture=lowerCamelCase_      ,							)

       def 						UpperCAmelCase(   self      :     int      ,							lowerCamelCase_      :     Optional[int]      ,							lowerCamelCase_      :     str      ,							lowerCamelCase_      :     int      ,							lowerCamelCase_      :     int      ,							lowerCamelCase_      :     Union[str, Any]      ,							lowerCamelCase_      :     Optional[Any]      ,							lowerCamelCase_      :     Optional[int]    ):
            a_    :     List[str]										=    FalconModel(config=lowerCamelCase_    )
            model.to(lowerCamelCase_    )
            model.eval()
            a_    :     List[str]										=    model(lowerCamelCase_      ,							attention_mask=lowerCamelCase_    )
            a_    :     Any										=    model(lowerCamelCase_    )
            self.parent.assertEqual(result.last_hidden_state.shape      ,							(self.batch_size, self.seq_length, self.hidden_size)    )

       def 						UpperCAmelCase(   self      :     List[str]      ,							lowerCamelCase_      :     Union[str, Any]      ,							lowerCamelCase_      :     int      ,							lowerCamelCase_      :     List[str]      ,							lowerCamelCase_      :     Optional[Any]      ,							lowerCamelCase_      :     List[Any]      ,							lowerCamelCase_      :     List[str]      ,							lowerCamelCase_      :     Tuple      ,							lowerCamelCase_      :     Union[str, Any]      ,							lowerCamelCase_      :     Any      ,							):
            a_    :     Optional[Any]										=    True
            a_    :     Dict										=    FalconModel(lowerCamelCase_    )
            model.to(lowerCamelCase_    )
            model.eval()
            a_    :     Tuple										=    model(
                lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							encoder_hidden_states=lowerCamelCase_      ,							encoder_attention_mask=lowerCamelCase_      ,							)
            a_    :     Optional[int]										=    model(
                lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							encoder_hidden_states=lowerCamelCase_      ,							)
            a_    :     Dict										=    model(lowerCamelCase_      ,							attention_mask=lowerCamelCase_    )
            self.parent.assertEqual(result.last_hidden_state.shape      ,							(self.batch_size, self.seq_length, self.hidden_size)    )

       def 						UpperCAmelCase(   self      :     Optional[Any]      ,							lowerCamelCase_      :     Optional[Any]      ,							lowerCamelCase_      :     Optional[int]      ,							lowerCamelCase_      :     Dict      ,							lowerCamelCase_      :     Optional[Any]      ,							lowerCamelCase_      :     int      ,							lowerCamelCase_      :     List[Any]      ,							lowerCamelCase_      :     Dict      ,							lowerCamelCase_      :     Dict      ,							lowerCamelCase_      :     int      ,							):
            a_    :     int										=    FalconForCausalLM(config=lowerCamelCase_    )
            model.to(lowerCamelCase_    )
            model.eval()
            a_    :     Tuple										=    model(lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							labels=lowerCamelCase_    )
            self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.seq_length, self.vocab_size)    )

       def 						UpperCAmelCase(   self      :     str      ,							lowerCamelCase_      :     List[Any]      ,							lowerCamelCase_      :     Optional[int]      ,							lowerCamelCase_      :     str      ,							lowerCamelCase_      :     int      ,							lowerCamelCase_      :     Any      ,							lowerCamelCase_      :     Optional[Any]      ,							lowerCamelCase_      :     Any      ,							lowerCamelCase_      :     Tuple      ,							lowerCamelCase_      :     Dict      ,							):
            a_    :     Optional[int]										=    True
            a_    :     Any										=    True
            a_    :     Optional[Any]										=    FalconForCausalLM(config=lowerCamelCase_    )
            model.to(lowerCamelCase_    )
            model.eval()

            # first forward pass
            a_    :     str										=    model(
                lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							encoder_hidden_states=lowerCamelCase_      ,							encoder_attention_mask=lowerCamelCase_      ,							use_cache=lowerCamelCase_      ,							)
            a_    :     Any										=    outputs.past_key_values

            # create hypothetical multiple next token and extent to next_input_ids
            a_    :     List[str]										=    ids_tensor((self.batch_size, 3)      ,							config.vocab_size    )
            a_    :     Optional[int]										=    ids_tensor((self.batch_size, 3)      ,							vocab_size=2    )

            # append to next input_ids and
            a_    :     List[Any]										=    torch.cat([input_ids, next_tokens]      ,							dim=-1    )
            a_    :     str										=    torch.cat([input_mask, next_mask]      ,							dim=-1    )

            a_    :     Any										=    model(
                lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							encoder_hidden_states=lowerCamelCase_      ,							encoder_attention_mask=lowerCamelCase_      ,							output_hidden_states=lowerCamelCase_      ,							)["""hidden_states"""][0]
            a_    :     Tuple										=    model(
                lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							encoder_hidden_states=lowerCamelCase_      ,							encoder_attention_mask=lowerCamelCase_      ,							past_key_values=lowerCamelCase_      ,							output_hidden_states=lowerCamelCase_      ,							)["""hidden_states"""][0]

            # select random slice
            a_    :     Tuple										=    ids_tensor((1,)      ,							output_from_past.shape[-1]    ).item()
            a_    :     Dict										=    output_from_no_past[:, -3:, random_slice_idx].detach()
            a_    :     List[str]										=    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(lowerCamelCase_      ,							lowerCamelCase_      ,							atol=1E-3    )    )

       def 						UpperCAmelCase(   self      :     str    ):
            a_    :     List[Any]										=    self.prepare_config_and_inputs()
            (
                (
                a_
            )			,			(
                a_
            )			,			(
                a_
            )			,			(
                a_
            )			,			(
                a_
            )			,			(
                a_
            )			,			(
                a_
            )			,			
            )    :     Dict										=    config_and_inputs
            a_    :     int										=    {"""input_ids""": input_ids, """attention_mask""": input_mask}
            return config, inputs_dict


@require_torch
class   a__	(						lowerCAmelCase_						,       lowerCAmelCase_						,       lowerCAmelCase_						,       unittest.TestCase    ):
       lowerCamelCase__:     Optional[int]							    =     (
           (
               FalconModel,
               FalconForCausalLM,
               FalconForSequenceClassification,
               FalconForTokenClassification,
               FalconForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       lowerCamelCase__:     Optional[int]							    =     (FalconForCausalLM,) if is_torch_available() else ()
       lowerCamelCase__:     Union[str, Any]							    =     (
           {
               """feature-extraction""": FalconModel,
               """text-classification""": FalconForSequenceClassification,
               """text-generation""": FalconForCausalLM,
               """question-answering""": FalconForQuestionAnswering,
               """token-classification""": FalconForTokenClassification,
               """zero-shot""": FalconForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       lowerCamelCase__:     Optional[int]							    =     False
       lowerCamelCase__:     Optional[int]							    =     False

       def 						UpperCAmelCase(   self      :     int    ):
            a_    :     Optional[int]										=    FalconModelTester(self    )
            a_    :     Any										=    ConfigTester(self      ,							config_class=lowerCamelCase_      ,							hidden_size=3_7    )

       def 						UpperCAmelCase(   self      :     List[Any]    ):
            self.config_tester.run_common_tests()

       def 						UpperCAmelCase(   self      :     Optional[int]    ):
            a_    :     List[str]										=    self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     List[str]    ):
            a_			,			*a_    :     Dict										=    self.model_tester.prepare_config_and_inputs()
            for alibi in [True, False]:
                 a_    :     int										=    alibi
                 self.model_tester.create_and_check_model(lowerCamelCase_      ,							*lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Any    ):
            a_			,			a_    :     Optional[int]										=    self.model_tester.prepare_config_and_inputs_for_common()
            a_    :     List[str]										=    3
            a_    :     Optional[int]										=    input_dict["""input_ids"""]
            a_    :     List[str]										=    input_ids.ne(1    ).to(lowerCamelCase_    )
            a_    :     Dict										=    ids_tensor([self.model_tester.batch_size]      ,							self.model_tester.type_sequence_label_size    )
            a_    :     int										=    FalconForSequenceClassification(lowerCamelCase_    )
            model.to(lowerCamelCase_    )
            model.eval()
            a_    :     str										=    model(lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							labels=lowerCamelCase_    )
            self.assertEqual(result.logits.shape      ,							(self.model_tester.batch_size, self.model_tester.num_labels)    )

       def 						UpperCAmelCase(   self      :     Dict    ):
            a_			,			a_    :     Dict										=    self.model_tester.prepare_config_and_inputs_for_common()
            a_    :     Dict										=    3
            a_    :     Tuple										=    """single_label_classification"""
            a_    :     List[Any]										=    input_dict["""input_ids"""]
            a_    :     str										=    input_ids.ne(1    ).to(lowerCamelCase_    )
            a_    :     Optional[Any]										=    ids_tensor([self.model_tester.batch_size]      ,							self.model_tester.type_sequence_label_size    )
            a_    :     List[Any]										=    FalconForSequenceClassification(lowerCamelCase_    )
            model.to(lowerCamelCase_    )
            model.eval()
            a_    :     Dict										=    model(lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							labels=lowerCamelCase_    )
            self.assertEqual(result.logits.shape      ,							(self.model_tester.batch_size, self.model_tester.num_labels)    )

       def 						UpperCAmelCase(   self      :     Tuple    ):
            a_			,			a_    :     Tuple										=    self.model_tester.prepare_config_and_inputs_for_common()
            a_    :     str										=    input_dict["""input_ids"""]
            a_    :     Dict										=    FalconForCausalLM(lowerCamelCase_    )
            model.to(lowerCamelCase_    )
            model.eval()
            a_    :     Optional[int]										=    model(lowerCamelCase_      ,							use_cache=lowerCamelCase_    )
            a_    :     int										=    input_ids.shape[0]
            a_    :     Union[str, Any]										=    model._convert_to_rw_cache(result.past_key_values    )
            a_    :     Tuple										=    model._convert_cache_to_standard_format(lowerCamelCase_      ,							lowerCamelCase_    )
            for layer in range(len(lowerCamelCase_    )    ):
                 for tensor_idx in range(2    ):
                      self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3    )
                      self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4    )
                      self.assertTrue(
                          torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]    )    )

       def 						UpperCAmelCase(   self      :     Optional[int]    ):
            a_			,			a_    :     Optional[int]										=    self.model_tester.prepare_config_and_inputs_for_common()
            a_    :     Tuple										=    3
            a_    :     int										=    """multi_label_classification"""
            a_    :     List[str]										=    input_dict["""input_ids"""]
            a_    :     List[str]										=    input_ids.ne(1    ).to(lowerCamelCase_    )
            a_    :     Dict										=    ids_tensor(
                [self.model_tester.batch_size, config.num_labels]      ,							self.model_tester.type_sequence_label_size    ).to(torch.float    )
            a_    :     List[Any]										=    FalconForSequenceClassification(lowerCamelCase_    )
            model.to(lowerCamelCase_    )
            model.eval()
            a_    :     Dict										=    model(lowerCamelCase_      ,							attention_mask=lowerCamelCase_      ,							labels=lowerCamelCase_    )
            self.assertEqual(result.logits.shape      ,							(self.model_tester.batch_size, self.model_tester.num_labels)    )

       def 						UpperCAmelCase(   self      :     List[Any]    ):
            # Falcon can have different numbers of KV-heads than the number of query heads, so we need
            # to override this test to use the right head counts.
            for model_class in self.all_generative_model_classes:
                 a_			,			a_    :     List[Any]										=    self.model_tester.prepare_config_and_inputs_for_common()

                 # If it doesn't support cache, pass the test
                 if not hasattr(lowerCamelCase_      ,							"""use_cache"""    ):
                      return

                 a_    :     Union[str, Any]										=    model_class(lowerCamelCase_    ).to(lowerCamelCase_    )
                 if "use_cache" not in inputs:
                      a_    :     List[Any]										=    True
                 a_    :     str										=    model(**lowerCamelCase_    )

                 # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
                 if "past_key_values" not in outputs:
                      return

                 a_    :     Dict										=    (
                     getattr(lowerCamelCase_      ,							"""decoder_layers"""      ,							lowerCamelCase_    )
                     or getattr(lowerCamelCase_      ,							"""num_decoder_layers"""      ,							lowerCamelCase_    )
                     or config.num_hidden_layers
                 )
                 a_    :     List[Any]										=    getattr(lowerCamelCase_      ,							"""num_kv_heads"""      ,							config.num_attention_heads    )
                 a_    :     Optional[int]										=    getattr(lowerCamelCase_      ,							"""d_model"""      ,							config.hidden_size    )
                 a_    :     List[str]										=    embed_dim // num_attention_heads

                 a_    :     Union[str, Any]										=    outputs["""past_key_values"""]
                 self.assertEqual(len(lowerCamelCase_    )      ,							lowerCamelCase_    )

                 a_			,			a_    :     int										=    inputs["""input_ids"""].shape
                 for i in range(lowerCamelCase_    ):
                      if config.new_decoder_architecture:
                           a_    :     List[str]										=    config.num_attention_heads
                      elif config.multi_query:
                           a_    :     str										=    1
                      self.assertEqual(len(past_kv[0]    )      ,							2    )  # K V for the decoder = 2
                      self.assertEqual(
                          past_kv[i][0].shape      ,							(batch_size, num_attention_heads, seq_length, per_head_embed_dim)    )
                      self.assertEqual(
                          past_kv[i][1].shape      ,							(batch_size, num_attention_heads, seq_length, per_head_embed_dim)    )


@require_torch
class   a__	(						unittest.TestCase    ):

       @slow
       def 						UpperCAmelCase(   self      :     List[str]    ):
            a_    :     Union[str, Any]										=    AutoTokenizer.from_pretrained("""Rocketknight1/falcon-rw-1b"""    )
            a_    :     Dict										=    FalconForCausalLM.from_pretrained("""Rocketknight1/falcon-rw-1b"""    )
            model.eval()
            model.to(lowerCamelCase_    )
            a_    :     Any										=    tokenizer("""My favorite food is"""      ,							return_tensors="""pt"""    ).to(lowerCamelCase_    )

            a_    :     str										=    (
                """My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday."""
            )

            a_    :     Optional[int]										=    model.generate(**lowerCamelCase_      ,							do_sample=lowerCamelCase_      ,							max_new_tokens=1_9    )
            a_    :     List[Any]										=    tokenizer.batch_decode(lowerCamelCase_    )[0]

            self.assertEqual(lowerCamelCase_      ,							lowerCamelCase_    )

       @slow
       def 						UpperCAmelCase(   self      :     int    ):
            # The big models are way too big for the CI, so we use tiny random models that resemble their
            # architectures but with much smaller and fewer layers
            for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
                 a_    :     Any										=    AutoTokenizer.from_pretrained(lowerCamelCase_    )
                 a_    :     Optional[int]										=    FalconForCausalLM.from_pretrained(lowerCamelCase_    )
                 model.eval()
                 model.to(lowerCamelCase_    )
                 a_    :     str										=    tokenizer("""My favorite food is"""      ,							return_tensors="""pt"""    ).to(lowerCamelCase_    )

                 # We just test that these run without errors - the models are randomly initialized
                 # and so the actual text outputs will be garbage
                 model.generate(**lowerCamelCase_      ,							do_sample=lowerCamelCase_      ,							max_new_tokens=4    )
                 model.generate(**lowerCamelCase_      ,							do_sample=lowerCamelCase_      ,							max_new_tokens=4    )
                 model.generate(**lowerCamelCase_      ,							num_beams=2      ,							max_new_tokens=4    )

       @slow
       def 						UpperCAmelCase(   self      :     Any    ):
            # The big models are way too big for the CI, so we use tiny random models that resemble their
            # architectures but with much smaller and fewer layers
            with torch.no_grad():
                 for repo in [
                     "Rocketknight1/falcon-rw-1b",
                     "Rocketknight1/tiny-random-falcon-7b",
                     "Rocketknight1/tiny-random-falcon-40b",
                 ]:
                      a_    :     str										=    AutoTokenizer.from_pretrained(lowerCamelCase_    )
                      a_    :     Optional[int]										=    FalconForCausalLM.from_pretrained(lowerCamelCase_    )
                      model.eval()
                      model.to(device=lowerCamelCase_    )
                      a_    :     Optional[Any]										=    tokenizer("""My favorite food is"""      ,							return_tensors="""pt"""    ).to(lowerCamelCase_    )

                      # Test results are the same with and without cache
                      a_    :     Optional[int]										=    model.generate(**lowerCamelCase_      ,							do_sample=lowerCamelCase_      ,							max_new_tokens=2_0      ,							use_cache=lowerCamelCase_    )
                      a_    :     int										=    model.generate(**lowerCamelCase_      ,							do_sample=lowerCamelCase_      ,							max_new_tokens=2_0      ,							use_cache=lowerCamelCase_    )
                      self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0    )







from typing import TYPE_CHECKING

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


__lowerCamelCase        =     {
    '''configuration_altclip''': [
        '''ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''AltCLIPConfig''',
        '''AltCLIPTextConfig''',
        '''AltCLIPVisionConfig''',
    ],
    '''processing_altclip''': ['''AltCLIPProcessor'''],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCamelCase        =     [
           '''ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''AltCLIPPreTrainedModel''',
           '''AltCLIPModel''',
           '''AltCLIPTextModel''',
           '''AltCLIPVisionModel''',
       ]


if TYPE_CHECKING:
       from .configuration_altclip import (
           ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
           AltCLIPConfig,
           AltCLIPTextConfig,
           AltCLIPVisionConfig,
       )
       from .processing_altclip import AltCLIPProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_altclip import (
                  ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
                  AltCLIPModel,
                  AltCLIPPreTrainedModel,
                  AltCLIPTextModel,
                  AltCLIPVisionModel,
              )


else:
       import sys

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



