


import json
import os
import pickle
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers import is_faiss_available
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bart.tokenization_bart import BartTokenizer
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.dpr.tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer
from transformers.models.rag.configuration_rag import RagConfig
from transformers.models.rag.retrieval_rag import CustomHFIndex, RagRetriever
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_sentencepiece, require_tokenizers, require_torch


if is_faiss_available():
     import faiss






@require_faiss
class   _lowerCamelCase (					UpperCamelCase			):




       """simple docstring"""



       def        _snake_case       (      self		)->str:




         '''simple docstring'''





         A_      :				Optional[Any]		     =					tempfile.mkdtemp()
         A_      :				List[str]		     =					8

         # DPR tok
         A_      :				Any		     =					[
             '''[UNK]''',
             '''[CLS]''',
             '''[SEP]''',
             '''[PAD]''',
             '''[MASK]''',
             '''want''',
             '''##want''',
             '''##ed''',
             '''wa''',
             '''un''',
             '''runn''',
             '''##ing''',
             ''',''',
             '''low''',
             '''lowest''',
         ]
         A_      :				Dict		     =					os.path.join(self.tmpdirname				,       '''dpr_tokenizer'''		)
         os.makedirs(_SCREAMING_SNAKE_CASE				,       exist_ok=_SCREAMING_SNAKE_CASE		)
         A_      :				List[Any]		     =					os.path.join(_SCREAMING_SNAKE_CASE				,       DPR_VOCAB_FILES_NAMES['''vocab_file''']		)
         with open(self.vocab_file				,       '''w'''				,       encoding='''utf-8'''		) as vocab_writer:
           vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]		)		)

         # BART tok
         A_      :				Optional[Any]		     =					[
             '''l''',
             '''o''',
             '''w''',
             '''e''',
             '''r''',
             '''s''',
             '''t''',
             '''i''',
             '''d''',
             '''n''',
             '''\u0120''',
             '''\u0120l''',
             '''\u0120n''',
             '''\u0120lo''',
             '''\u0120low''',
             '''er''',
             '''\u0120lowest''',
             '''\u0120newer''',
             '''\u0120wider''',
             '''<unk>''',
         ]
         A_      :				List[Any]		     =					dict(zip(_SCREAMING_SNAKE_CASE				,       range(len(_SCREAMING_SNAKE_CASE		)		)		)		)
         A_      :				Optional[int]		     =					['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
         A_      :				Any		     =					{'''unk_token''': '''<unk>'''}

         A_      :				int		     =					os.path.join(self.tmpdirname				,       '''bart_tokenizer'''		)
         os.makedirs(_SCREAMING_SNAKE_CASE				,       exist_ok=_SCREAMING_SNAKE_CASE		)
         A_      :				List[str]		     =					os.path.join(_SCREAMING_SNAKE_CASE				,       BART_VOCAB_FILES_NAMES['''vocab_file''']		)
         A_      :				List[Any]		     =					os.path.join(_SCREAMING_SNAKE_CASE				,       BART_VOCAB_FILES_NAMES['''merges_file''']		)
         with open(self.vocab_file				,       '''w'''				,       encoding='''utf-8'''		) as fp:
           fp.write(json.dumps(_SCREAMING_SNAKE_CASE		) + '''\n'''		)
         with open(self.merges_file				,       '''w'''				,       encoding='''utf-8'''		) as fp:
           fp.write('''\n'''.join(_SCREAMING_SNAKE_CASE		)		)



       def        _snake_case       (      self		)->DPRQuestionEncoderTokenizer:




         '''simple docstring'''





         return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname				,       '''dpr_tokenizer'''		)		)



       def        _snake_case       (      self		)->DPRContextEncoderTokenizer:




         '''simple docstring'''





         return DPRContextEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname				,       '''dpr_tokenizer'''		)		)



       def        _snake_case       (      self		)->BartTokenizer:




         '''simple docstring'''





         return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname				,       '''bart_tokenizer'''		)		)



       def        _snake_case       (      self		)->Tuple:




         '''simple docstring'''





         shutil.rmtree(self.tmpdirname		)



       def        _snake_case       (      self		)->List[str]:




         '''simple docstring'''





         A_      :				Tuple		     =					Dataset.from_dict(
             {
                 '''id''': ['''0''', '''1'''],
                 '''text''': ['''foo''', '''bar'''],
                 '''title''': ['''Foo''', '''Bar'''],
                 '''embeddings''': [np.ones(self.retrieval_vector_size		), 2 * np.ones(self.retrieval_vector_size		)],
             }		)
         dataset.add_faiss_index('''embeddings'''				,       string_factory='''Flat'''				,       metric_type=faiss.METRIC_INNER_PRODUCT		)
         return dataset



       def        _snake_case       (      self		)->Any:




         '''simple docstring'''





         A_      :				Optional[int]		     =					self.get_dummy_dataset()
         A_      :				Union[str, Any]		     =					RagConfig(
             retrieval_vector_size=self.retrieval_vector_size				,       question_encoder=DPRConfig().to_dict()				,       generator=BartConfig().to_dict()				,       )
         with patch('''transformers.models.rag.retrieval_rag.load_dataset'''		) as mock_load_dataset:
           A_      :				Tuple		     =					dataset
           A_      :				Union[str, Any]		     =					RagRetriever(
               _SCREAMING_SNAKE_CASE				,       question_encoder_tokenizer=self.get_dpr_tokenizer()				,       generator_tokenizer=self.get_bart_tokenizer()				,       )
         return retriever



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE		)->Optional[Any]:




         '''simple docstring'''





         A_      :				Optional[int]		     =					self.get_dummy_dataset()
         A_      :				Dict		     =					RagConfig(
             retrieval_vector_size=self.retrieval_vector_size				,       question_encoder=DPRConfig().to_dict()				,       generator=BartConfig().to_dict()				,       index_name='''custom'''				,       )
         if from_disk:
           A_      :				Optional[int]		     =					os.path.join(self.tmpdirname				,       '''dataset'''		)
           A_      :				Any		     =					os.path.join(self.tmpdirname				,       '''index.faiss'''		)
           dataset.get_index('''embeddings'''		).save(os.path.join(self.tmpdirname				,       '''index.faiss'''		)		)
           dataset.drop_index('''embeddings'''		)
           dataset.save_to_disk(os.path.join(self.tmpdirname				,       '''dataset'''		)		)
           del dataset
           A_      :				Optional[int]		     =					RagRetriever(
               _SCREAMING_SNAKE_CASE				,       question_encoder_tokenizer=self.get_dpr_tokenizer()				,       generator_tokenizer=self.get_bart_tokenizer()				,       )
         else:
           A_      :				Optional[Any]		     =					RagRetriever(
               _SCREAMING_SNAKE_CASE				,       question_encoder_tokenizer=self.get_dpr_tokenizer()				,       generator_tokenizer=self.get_bart_tokenizer()				,       index=CustomHFIndex(config.retrieval_vector_size				,       _SCREAMING_SNAKE_CASE		)				,       )
         return retriever



       def        _snake_case       (      self		)->Optional[int]:




         '''simple docstring'''





         A_      :				List[str]		     =					Dataset.from_dict(
             {
                 '''id''': ['''0''', '''1'''],
                 '''text''': ['''foo''', '''bar'''],
                 '''title''': ['''Foo''', '''Bar'''],
                 '''embeddings''': [np.ones(self.retrieval_vector_size + 1		), 2 * np.ones(self.retrieval_vector_size + 1		)],
             }		)
         dataset.add_faiss_index('''embeddings'''				,       string_factory='''Flat'''				,       metric_type=faiss.METRIC_INNER_PRODUCT		)

         A_      :				List[str]		     =					os.path.join(self.tmpdirname				,       '''hf_bert_base.hnswSQ8_correct_phi_128.c_index'''		)
         dataset.save_faiss_index('''embeddings'''				,       index_file_name + '''.index.dpr'''		)
         pickle.dump(dataset['''id''']				,       open(index_file_name + '''.index_meta.dpr'''				,       '''wb'''		)		)

         A_      :				Any		     =					os.path.join(self.tmpdirname				,       '''psgs_w100.tsv.pkl'''		)
         A_      :				List[str]		     =					{sample['''id''']: [sample['''text'''], sample['''title''']] for sample in dataset}
         pickle.dump(_SCREAMING_SNAKE_CASE				,       open(_SCREAMING_SNAKE_CASE				,       '''wb'''		)		)

         A_      :				Optional[int]		     =					RagConfig(
             retrieval_vector_size=self.retrieval_vector_size				,       question_encoder=DPRConfig().to_dict()				,       generator=BartConfig().to_dict()				,       index_name='''legacy'''				,       index_path=self.tmpdirname				,       )
         A_      :				Optional[Any]		     =					RagRetriever(
             _SCREAMING_SNAKE_CASE				,       question_encoder_tokenizer=self.get_dpr_tokenizer()				,       generator_tokenizer=self.get_bart_tokenizer()		)
         return retriever



       def        _snake_case       (      self		)->Optional[Any]:




         '''simple docstring'''





         A_      :				str		     =					1
         A_      :				int		     =					self.get_dummy_canonical_hf_index_retriever()
         A_      :				str		     =					np.array(
             [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
         A_     ,       A_     ,       A_      :				Optional[Any]		     =					retriever.retrieve(_SCREAMING_SNAKE_CASE				,       n_docs=_SCREAMING_SNAKE_CASE		)
         self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)		)
         self.assertEqual(len(_SCREAMING_SNAKE_CASE		)				,       2		)
         self.assertEqual(sorted(doc_dicts[0]		)				,       ['''embeddings''', '''id''', '''text''', '''title''']		)
         self.assertEqual(len(doc_dicts[0]['''id''']		)				,       _SCREAMING_SNAKE_CASE		)
         self.assertEqual(doc_dicts[0]['''id'''][0]				,       '''1'''		)  # max inner product is reached with second doc
         self.assertEqual(doc_dicts[1]['''id'''][0]				,       '''0'''		)  # max inner product is reached with first doc
         self.assertListEqual(doc_ids.tolist()				,       [[1], [0]]		)



       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         A_      :				Optional[Any]		     =					self.get_dummy_canonical_hf_index_retriever()
         with tempfile.TemporaryDirectory() as tmp_dirname:
           with patch('''transformers.models.rag.retrieval_rag.load_dataset'''		) as mock_load_dataset:
             A_      :				List[Any]		     =					self.get_dummy_dataset()
             retriever.save_pretrained(_SCREAMING_SNAKE_CASE		)
             A_      :				Dict		     =					RagRetriever.from_pretrained(_SCREAMING_SNAKE_CASE		)
             self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
             A_      :				Dict		     =					np.array(
                 [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
             A_      :				int		     =					retriever.retrieve(_SCREAMING_SNAKE_CASE				,       n_docs=1		)
             self.assertTrue(out is not None		)



       def        _snake_case       (      self		)->Optional[Any]:




         '''simple docstring'''





         A_      :				List[str]		     =					1
         A_      :				Any		     =					self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE		)
         A_      :				Optional[int]		     =					np.array(
             [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
         A_     ,       A_     ,       A_      :				Optional[Any]		     =					retriever.retrieve(_SCREAMING_SNAKE_CASE				,       n_docs=_SCREAMING_SNAKE_CASE		)
         self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)		)
         self.assertEqual(len(_SCREAMING_SNAKE_CASE		)				,       2		)
         self.assertEqual(sorted(doc_dicts[0]		)				,       ['''embeddings''', '''id''', '''text''', '''title''']		)
         self.assertEqual(len(doc_dicts[0]['''id''']		)				,       _SCREAMING_SNAKE_CASE		)
         self.assertEqual(doc_dicts[0]['''id'''][0]				,       '''1'''		)  # max inner product is reached with second doc
         self.assertEqual(doc_dicts[1]['''id'''][0]				,       '''0'''		)  # max inner product is reached with first doc
         self.assertListEqual(doc_ids.tolist()				,       [[1], [0]]		)



       def        _snake_case       (      self		)->Optional[Any]:




         '''simple docstring'''





         A_      :				Optional[int]		     =					self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE		)
         with tempfile.TemporaryDirectory() as tmp_dirname:
           retriever.save_pretrained(_SCREAMING_SNAKE_CASE		)
           A_      :				Optional[int]		     =					RagRetriever.from_pretrained(_SCREAMING_SNAKE_CASE		)
           self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
           A_      :				str		     =					np.array(
               [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
           A_      :				Optional[Any]		     =					retriever.retrieve(_SCREAMING_SNAKE_CASE				,       n_docs=1		)
           self.assertTrue(out is not None		)



       def        _snake_case       (      self		)->Optional[Any]:




         '''simple docstring'''





         A_      :				str		     =					1
         A_      :				List[Any]		     =					self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE		)
         A_      :				Optional[int]		     =					np.array(
             [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
         A_     ,       A_     ,       A_      :				Optional[Any]		     =					retriever.retrieve(_SCREAMING_SNAKE_CASE				,       n_docs=_SCREAMING_SNAKE_CASE		)
         self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)		)
         self.assertEqual(len(_SCREAMING_SNAKE_CASE		)				,       2		)
         self.assertEqual(sorted(doc_dicts[0]		)				,       ['''embeddings''', '''id''', '''text''', '''title''']		)
         self.assertEqual(len(doc_dicts[0]['''id''']		)				,       _SCREAMING_SNAKE_CASE		)
         self.assertEqual(doc_dicts[0]['''id'''][0]				,       '''1'''		)  # max inner product is reached with second doc
         self.assertEqual(doc_dicts[1]['''id'''][0]				,       '''0'''		)  # max inner product is reached with first doc
         self.assertListEqual(doc_ids.tolist()				,       [[1], [0]]		)



       def        _snake_case       (      self		)->Union[str, Any]:




         '''simple docstring'''





         A_      :				Any		     =					self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE		)
         with tempfile.TemporaryDirectory() as tmp_dirname:
           retriever.save_pretrained(_SCREAMING_SNAKE_CASE		)
           A_      :				List[Any]		     =					RagRetriever.from_pretrained(_SCREAMING_SNAKE_CASE		)
           self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
           A_      :				Optional[Any]		     =					np.array(
               [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
           A_      :				Dict		     =					retriever.retrieve(_SCREAMING_SNAKE_CASE				,       n_docs=1		)
           self.assertTrue(out is not None		)



       def        _snake_case       (      self		)->str:




         '''simple docstring'''





         A_      :				Optional[Any]		     =					1
         A_      :				Tuple		     =					self.get_dummy_legacy_index_retriever()
         A_      :				int		     =					np.array(
             [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
         A_     ,       A_     ,       A_      :				Union[str, Any]		     =					retriever.retrieve(_SCREAMING_SNAKE_CASE				,       n_docs=_SCREAMING_SNAKE_CASE		)
         self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)		)
         self.assertEqual(len(_SCREAMING_SNAKE_CASE		)				,       2		)
         self.assertEqual(sorted(doc_dicts[0]		)				,       ['''text''', '''title''']		)
         self.assertEqual(len(doc_dicts[0]['''text''']		)				,       _SCREAMING_SNAKE_CASE		)
         self.assertEqual(doc_dicts[0]['''text'''][0]				,       '''bar'''		)  # max inner product is reached with second doc
         self.assertEqual(doc_dicts[1]['''text'''][0]				,       '''foo'''		)  # max inner product is reached with first doc
         self.assertListEqual(doc_ids.tolist()				,       [[1], [0]]		)



       def        _snake_case       (      self		)->Union[str, Any]:




         '''simple docstring'''





         A_      :				Dict		     =					self.get_dummy_legacy_index_retriever()
         with tempfile.TemporaryDirectory() as tmp_dirname:
           retriever.save_pretrained(_SCREAMING_SNAKE_CASE		)
           A_      :				List[str]		     =					RagRetriever.from_pretrained(_SCREAMING_SNAKE_CASE		)
           self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
           A_      :				Dict		     =					np.array(
               [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
           A_      :				Union[str, Any]		     =					retriever.retrieve(_SCREAMING_SNAKE_CASE				,       n_docs=1		)
           self.assertTrue(out is not None		)



       @require_torch
       @require_tokenizers
       @require_sentencepiece
       def        _snake_case       (      self		)->Optional[int]:




         '''simple docstring'''





         import torch

         A_      :				Optional[Any]		     =					1
         A_      :				List[Any]		     =					self.get_dummy_canonical_hf_index_retriever()
         A_      :				str		     =					[[5, 7], [10, 11]]
         A_      :				int		     =					np.array(
             [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
         A_      :				List[Any]		     =					retriever(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       prefix=retriever.config.generator.prefix				,       n_docs=_SCREAMING_SNAKE_CASE		)
         A_     ,       A_     ,       A_      :				int		     =					(
             out['''context_input_ids'''],
             out['''context_attention_mask'''],
             out['''retrieved_doc_embeds'''],
         )
         self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)		)
         self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       np.ndarray		)

         A_      :				Tuple		     =					retriever(
             _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       prefix=retriever.config.generator.prefix				,       n_docs=_SCREAMING_SNAKE_CASE				,       return_tensors='''pt'''				,       )
         A_     ,       A_     ,       A_     ,       A_      :				Optional[int]		     =					(  # noqa: F841
             out['''context_input_ids'''],
             out['''context_attention_mask'''],
             out['''retrieved_doc_embeds'''],
             out['''doc_ids'''],
         )
         self.assertEqual(retrieved_doc_embeds.shape				,       (2, n_docs, self.retrieval_vector_size)		)
         self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       torch.Tensor		)
         self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       torch.Tensor		)
         self.assertIsInstance(_SCREAMING_SNAKE_CASE				,       torch.Tensor		)







       @require_torch
       @require_tokenizers
       @require_sentencepiece
       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         A_      :				Tuple		     =					self.get_dpr_ctx_encoder_tokenizer()
         A_      :				Optional[int]		     =					1
         A_      :				Optional[Any]		     =					self.get_dummy_custom_hf_index_retriever(from_disk=_SCREAMING_SNAKE_CASE		)
         retriever.set_ctx_encoder_tokenizer(_SCREAMING_SNAKE_CASE		)

         A_      :				Optional[Any]		     =					[[5, 7], [10, 11]]
         A_      :				Optional[int]		     =					np.array(
             [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,       dtype=np.floataa		)
         A_      :				Any		     =					retriever(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       prefix=retriever.config.generator.prefix				,       n_docs=_SCREAMING_SNAKE_CASE		)

         self.assertEqual(
             len(_SCREAMING_SNAKE_CASE		)				,       6		)  # check whether the retriever output consist of 6 attributes including tokenized docs
         self.assertEqual(
             all(k in out for k in ('''tokenized_doc_ids''', '''tokenized_doc_attention_mask''')		)				,       _SCREAMING_SNAKE_CASE		)  # check for doc token related keys in dictionary.








from typing import TYPE_CHECKING

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


UpperCamelCase								=	{
    """configuration_nezha""": ["""NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """NezhaConfig"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase								=	[
         """NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """NezhaForNextSentencePrediction""",
         """NezhaForMaskedLM""",
         """NezhaForPreTraining""",
         """NezhaForMultipleChoice""",
         """NezhaForQuestionAnswering""",
         """NezhaForSequenceClassification""",
         """NezhaForTokenClassification""",
         """NezhaModel""",
         """NezhaPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_nezha import (
              NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST,
              NezhaForMaskedLM,
              NezhaForMultipleChoice,
              NezhaForNextSentencePrediction,
              NezhaForPreTraining,
              NezhaForQuestionAnswering,
              NezhaForSequenceClassification,
              NezhaForTokenClassification,
              NezhaModel,
              NezhaPreTrainedModel,
          )


else:
     import sys

     UpperCamelCase								=	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




