

"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE_       :						str					=    {
    """auto_factory""": ["""get_values"""],
    """configuration_auto""": ["""ALL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CONFIG_MAPPING""", """MODEL_NAMES_MAPPING""", """AutoConfig"""],
    """feature_extraction_auto""": ["""FEATURE_EXTRACTOR_MAPPING""", """AutoFeatureExtractor"""],
    """image_processing_auto""": ["""IMAGE_PROCESSOR_MAPPING""", """AutoImageProcessor"""],
    """processing_auto""": ["""PROCESSOR_MAPPING""", """AutoProcessor"""],
    """tokenization_auto""": ["""TOKENIZER_MAPPING""", """AutoTokenizer"""],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_       :						Any					=    [
     """MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
     """MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING""",
     """MODEL_FOR_AUDIO_XVECTOR_MAPPING""",
     """MODEL_FOR_BACKBONE_MAPPING""",
     """MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING""",
     """MODEL_FOR_CAUSAL_LM_MAPPING""",
     """MODEL_FOR_CTC_MAPPING""",
     """MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING""",
     """MODEL_FOR_DEPTH_ESTIMATION_MAPPING""",
     """MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
     """MODEL_FOR_IMAGE_SEGMENTATION_MAPPING""",
     """MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING""",
     """MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING""",
     """MODEL_FOR_MASKED_LM_MAPPING""",
     """MODEL_FOR_MASK_GENERATION_MAPPING""",
     """MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
     """MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
     """MODEL_FOR_OBJECT_DETECTION_MAPPING""",
     """MODEL_FOR_PRETRAINING_MAPPING""",
     """MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
     """MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING""",
     """MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
     """MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
     """MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
     """MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING""",
     """MODEL_FOR_TEXT_ENCODING_MAPPING""",
     """MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
     """MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING""",
     """MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING""",
     """MODEL_FOR_VISION_2_SEQ_MAPPING""",
     """MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING""",
     """MODEL_MAPPING""",
     """MODEL_WITH_LM_HEAD_MAPPING""",
     """MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING""",
     """MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING""",
     """AutoModel""",
     """AutoBackbone""",
     """AutoModelForAudioClassification""",
     """AutoModelForAudioFrameClassification""",
     """AutoModelForAudioXVector""",
     """AutoModelForCausalLM""",
     """AutoModelForCTC""",
     """AutoModelForDepthEstimation""",
     """AutoModelForImageClassification""",
     """AutoModelForImageSegmentation""",
     """AutoModelForInstanceSegmentation""",
     """AutoModelForMaskGeneration""",
     """AutoModelForTextEncoding""",
     """AutoModelForMaskedImageModeling""",
     """AutoModelForMaskedLM""",
     """AutoModelForMultipleChoice""",
     """AutoModelForNextSentencePrediction""",
     """AutoModelForObjectDetection""",
     """AutoModelForPreTraining""",
     """AutoModelForQuestionAnswering""",
     """AutoModelForSemanticSegmentation""",
     """AutoModelForSeq2SeqLM""",
     """AutoModelForSequenceClassification""",
     """AutoModelForSpeechSeq2Seq""",
     """AutoModelForTableQuestionAnswering""",
     """AutoModelForTokenClassification""",
     """AutoModelForUniversalSegmentation""",
     """AutoModelForVideoClassification""",
     """AutoModelForVision2Seq""",
     """AutoModelForVisualQuestionAnswering""",
     """AutoModelForDocumentQuestionAnswering""",
     """AutoModelWithLMHead""",
     """AutoModelForZeroShotImageClassification""",
     """AutoModelForZeroShotObjectDetection""",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_       :						List[str]					=    [
     """TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
     """TF_MODEL_FOR_CAUSAL_LM_MAPPING""",
     """TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
     """TF_MODEL_FOR_MASK_GENERATION_MAPPING""",
     """TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING""",
     """TF_MODEL_FOR_MASKED_LM_MAPPING""",
     """TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
     """TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
     """TF_MODEL_FOR_PRETRAINING_MAPPING""",
     """TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
     """TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING""",
     """TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING""",
     """TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
     """TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
     """TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
     """TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING""",
     """TF_MODEL_FOR_TEXT_ENCODING_MAPPING""",
     """TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
     """TF_MODEL_FOR_VISION_2_SEQ_MAPPING""",
     """TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING""",
     """TF_MODEL_MAPPING""",
     """TF_MODEL_WITH_LM_HEAD_MAPPING""",
     """TFAutoModel""",
     """TFAutoModelForAudioClassification""",
     """TFAutoModelForCausalLM""",
     """TFAutoModelForImageClassification""",
     """TFAutoModelForMaskedImageModeling""",
     """TFAutoModelForMaskedLM""",
     """TFAutoModelForMaskGeneration""",
     """TFAutoModelForMultipleChoice""",
     """TFAutoModelForNextSentencePrediction""",
     """TFAutoModelForPreTraining""",
     """TFAutoModelForDocumentQuestionAnswering""",
     """TFAutoModelForQuestionAnswering""",
     """TFAutoModelForSemanticSegmentation""",
     """TFAutoModelForSeq2SeqLM""",
     """TFAutoModelForSequenceClassification""",
     """TFAutoModelForSpeechSeq2Seq""",
     """TFAutoModelForTableQuestionAnswering""",
     """TFAutoModelForTextEncoding""",
     """TFAutoModelForTokenClassification""",
     """TFAutoModelForVision2Seq""",
     """TFAutoModelForZeroShotImageClassification""",
     """TFAutoModelWithLMHead""",
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_       :						str					=    [
     """FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
     """FLAX_MODEL_FOR_CAUSAL_LM_MAPPING""",
     """FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
     """FLAX_MODEL_FOR_MASKED_LM_MAPPING""",
     """FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
     """FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
     """FLAX_MODEL_FOR_PRETRAINING_MAPPING""",
     """FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
     """FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
     """FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
     """FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
     """FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
     """FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING""",
     """FLAX_MODEL_MAPPING""",
     """FlaxAutoModel""",
     """FlaxAutoModelForCausalLM""",
     """FlaxAutoModelForImageClassification""",
     """FlaxAutoModelForMaskedLM""",
     """FlaxAutoModelForMultipleChoice""",
     """FlaxAutoModelForNextSentencePrediction""",
     """FlaxAutoModelForPreTraining""",
     """FlaxAutoModelForQuestionAnswering""",
     """FlaxAutoModelForSeq2SeqLM""",
     """FlaxAutoModelForSequenceClassification""",
     """FlaxAutoModelForSpeechSeq2Seq""",
     """FlaxAutoModelForTokenClassification""",
     """FlaxAutoModelForVision2Seq""",
 ]


if TYPE_CHECKING:
 from .auto_factory import get_values
 from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
 from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
 from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
 from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
 from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_auto import (
      MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
      MODEL_FOR_AUDIO_XVECTOR_MAPPING,
      MODEL_FOR_BACKBONE_MAPPING,
      MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
      MODEL_FOR_CAUSAL_LM_MAPPING,
      MODEL_FOR_CTC_MAPPING,
      MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
      MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
      MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
      MODEL_FOR_MASK_GENERATION_MAPPING,
      MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
      MODEL_FOR_MASKED_LM_MAPPING,
      MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      MODEL_FOR_OBJECT_DETECTION_MAPPING,
      MODEL_FOR_PRETRAINING_MAPPING,
      MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
      MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_TEXT_ENCODING_MAPPING,
      MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
      MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
      MODEL_FOR_VISION_2_SEQ_MAPPING,
      MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
      MODEL_MAPPING,
      MODEL_WITH_LM_HEAD_MAPPING,
      AutoBackbone,
      AutoModel,
      AutoModelForAudioClassification,
      AutoModelForAudioFrameClassification,
      AutoModelForAudioXVector,
      AutoModelForCausalLM,
      AutoModelForCTC,
      AutoModelForDepthEstimation,
      AutoModelForDocumentQuestionAnswering,
      AutoModelForImageClassification,
      AutoModelForImageSegmentation,
      AutoModelForInstanceSegmentation,
      AutoModelForMaskedImageModeling,
      AutoModelForMaskedLM,
      AutoModelForMaskGeneration,
      AutoModelForMultipleChoice,
      AutoModelForNextSentencePrediction,
      AutoModelForObjectDetection,
      AutoModelForPreTraining,
      AutoModelForQuestionAnswering,
      AutoModelForSemanticSegmentation,
      AutoModelForSeqaSeqLM,
      AutoModelForSequenceClassification,
      AutoModelForSpeechSeqaSeq,
      AutoModelForTableQuestionAnswering,
      AutoModelForTextEncoding,
      AutoModelForTokenClassification,
      AutoModelForUniversalSegmentation,
      AutoModelForVideoClassification,
      AutoModelForVisionaSeq,
      AutoModelForVisualQuestionAnswering,
      AutoModelForZeroShotImageClassification,
      AutoModelForZeroShotObjectDetection,
      AutoModelWithLMHead,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_auto import (
      TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_MASK_GENERATION_MAPPING,
      TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
      TF_MODEL_FOR_MASKED_LM_MAPPING,
      TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      TF_MODEL_FOR_PRETRAINING_MAPPING,
      TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
      TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
      TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
      TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
      TF_MODEL_MAPPING,
      TF_MODEL_WITH_LM_HEAD_MAPPING,
      TFAutoModel,
      TFAutoModelForAudioClassification,
      TFAutoModelForCausalLM,
      TFAutoModelForDocumentQuestionAnswering,
      TFAutoModelForImageClassification,
      TFAutoModelForMaskedImageModeling,
      TFAutoModelForMaskedLM,
      TFAutoModelForMaskGeneration,
      TFAutoModelForMultipleChoice,
      TFAutoModelForNextSentencePrediction,
      TFAutoModelForPreTraining,
      TFAutoModelForQuestionAnswering,
      TFAutoModelForSemanticSegmentation,
      TFAutoModelForSeqaSeqLM,
      TFAutoModelForSequenceClassification,
      TFAutoModelForSpeechSeqaSeq,
      TFAutoModelForTableQuestionAnswering,
      TFAutoModelForTextEncoding,
      TFAutoModelForTokenClassification,
      TFAutoModelForVisionaSeq,
      TFAutoModelForZeroShotImageClassification,
      TFAutoModelWithLMHead,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_auto import (
      FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
      FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_MASKED_LM_MAPPING,
      FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      FLAX_MODEL_FOR_PRETRAINING_MAPPING,
      FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
      FLAX_MODEL_MAPPING,
      FlaxAutoModel,
      FlaxAutoModelForCausalLM,
      FlaxAutoModelForImageClassification,
      FlaxAutoModelForMaskedLM,
      FlaxAutoModelForMultipleChoice,
      FlaxAutoModelForNextSentencePrediction,
      FlaxAutoModelForPreTraining,
      FlaxAutoModelForQuestionAnswering,
      FlaxAutoModelForSeqaSeqLM,
      FlaxAutoModelForSequenceClassification,
      FlaxAutoModelForSpeechSeqaSeq,
      FlaxAutoModelForTokenClassification,
      FlaxAutoModelForVisionaSeq,
  )

else:
 import sys

 SCREAMING_SNAKE_CASE_       :						Dict					=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)










"""simple docstring"""
import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput



@dataclass
class      _UpperCAmelCase					(				__snake_case							):






		'''simple docstring'''

		lowerCamelCase__           =42
		lowerCamelCase__           =None
		lowerCamelCase__           =None



class      _UpperCAmelCase					(				unittest.TestCase							):






		'''simple docstring'''

		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Union[str, Any]         =							ModelOutputTest(a=30   )
			self.assertEqual(x.a							,			30   )
			self.assertIsNone(x.b   )
			self.assertIsNone(x.c   )
			with self.assertRaises(a_   ):
				__snake_case      :		str         =							x.d



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Union[str, Any]         =							ModelOutputTest(a=30							,			b=10   )
			self.assertEqual(x[0]							,			30   )
			self.assertEqual(x[1]							,			10   )
			self.assertEqual(x[:2]							,			(30, 10)   )
			self.assertEqual(x[:]							,			(30, 10)   )

			__snake_case      :		List[Any]         =							ModelOutputTest(a=30							,			c=10   )
			self.assertEqual(x[0]							,			30   )
			self.assertEqual(x[1]							,			10   )
			self.assertEqual(x[:2]							,			(30, 10)   )
			self.assertEqual(x[:]							,			(30, 10)   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Optional[int]         =							ModelOutputTest(a=30							,			b=10   )
			self.assertEqual(x['''a''']							,			30   )
			self.assertEqual(x['''b''']							,			10   )
			with self.assertRaises(a_   ):
				__snake_case      :		Optional[int]         =							x['''c''']

			__snake_case      :		Any         =							ModelOutputTest(a=30							,			c=10   )
			self.assertEqual(x['''a''']							,			30   )
			self.assertEqual(x['''c''']							,			10   )
			with self.assertRaises(a_   ):
				__snake_case      :		Optional[int]         =							x['''b''']



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Optional[int]         =							ModelOutputTest(a=30   )
			self.assertEqual(list(x.keys()   )							,			['''a''']   )
			self.assertEqual(list(x.values()   )							,			[30]   )
			self.assertEqual(list(x.items()   )							,			[('''a''', 30)]   )
			self.assertEqual(list(a_   )							,			['''a''']   )

			__snake_case      :		Optional[int]         =							ModelOutputTest(a=30							,			b=10   )
			self.assertEqual(list(x.keys()   )							,			['''a''', '''b''']   )
			self.assertEqual(list(x.values()   )							,			[30, 10]   )
			self.assertEqual(list(x.items()   )							,			[('''a''', 30), ('''b''', 10)]   )
			self.assertEqual(list(a_   )							,			['''a''', '''b''']   )

			__snake_case      :		Optional[Any]         =							ModelOutputTest(a=30							,			c=10   )
			self.assertEqual(list(x.keys()   )							,			['''a''', '''c''']   )
			self.assertEqual(list(x.values()   )							,			[30, 10]   )
			self.assertEqual(list(x.items()   )							,			[('''a''', 30), ('''c''', 10)]   )
			self.assertEqual(list(a_   )							,			['''a''', '''c''']   )

			with self.assertRaises(a_   ):
				__snake_case      :		Optional[int]         =							x.update({'''d''': 20}   )
			with self.assertRaises(a_   ):
				del x["a"]
			with self.assertRaises(a_   ):
				__snake_case      :		Union[str, Any]         =							x.pop('''a'''   )
			with self.assertRaises(a_   ):
				__snake_case      :		Optional[Any]         =							x.setdefault('''d'''							,			32   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		List[str]         =							ModelOutputTest(a=30   )
			__snake_case      :		Tuple         =							10
			self.assertEqual(x.a							,			10   )
			self.assertEqual(x['''a''']							,			10   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		List[str]         =							ModelOutputTest(a=30   )
			__snake_case      :		Any         =							10
			self.assertEqual(x.a							,			10   )
			self.assertEqual(x['''a''']							,			10   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		int         =							ModelOutputTest({'''a''': 30, '''b''': 10}   )
			self.assertEqual(list(x.keys()   )							,			['''a''', '''b''']   )
			self.assertEqual(x.a							,			30   )
			self.assertEqual(x.b							,			10   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Any         =							ModelOutputTest([('''a''', 30), ('''b''', 10)]   )
			self.assertEqual(list(x.keys()   )							,			['''a''', '''b''']   )
			self.assertEqual(x.a							,			30   )
			self.assertEqual(x.b							,			10   )

			with self.assertRaises(a_   ):
				__snake_case      :		List[Any]         =							ModelOutputTest([('''a''', 30), (10, 10)]   )

			__snake_case      :		Union[str, Any]         =							ModelOutputTest(a=(30, 30)   )
			self.assertEqual(list(x.keys()   )							,			['''a''']   )
			self.assertEqual(x.a							,			(30, 30)   )





