





"""simple docstring"""





import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

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


if is_torch_available():
						import torch

						from transformers import (
						    MODEL_FOR_PRETRAINING_MAPPING,
						    NezhaForMaskedLM,
						    NezhaForMultipleChoice,
						    NezhaForNextSentencePrediction,
						    NezhaForPreTraining,
						    NezhaForQuestionAnswering,
						    NezhaForSequenceClassification,
						    NezhaForTokenClassification,
						    NezhaModel,
						)
						from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST





class 				_lowerCamelCase					:


						def __init__(self      ,							__a      ,							__a=13      ,							__a=7      ,							__a=True      ,							__a=True      ,							__a=True      ,							__a=True      ,							__a=99      ,							__a=32      ,							__a=5      ,							__a=4      ,							__a=37      ,							__a="gelu"      ,							__a=0.1      ,							__a=0.1      ,							__a=1_28      ,							__a=32      ,							__a=16      ,							__a=2      ,							__a=0.02      ,							__a=3      ,							__a=4      ,							__a=None      ,							)       ->      List[str]:
								UpperCamelCase      =		parent
								UpperCamelCase      =		batch_size
								UpperCamelCase      =		seq_length
								UpperCamelCase      =		is_training
								UpperCamelCase      =		use_input_mask
								UpperCamelCase      =		use_token_type_ids
								UpperCamelCase      =		use_labels
								UpperCamelCase      =		vocab_size
								UpperCamelCase      =		hidden_size
								UpperCamelCase      =		num_hidden_layers
								UpperCamelCase      =		num_attention_heads
								UpperCamelCase      =		intermediate_size
								UpperCamelCase      =		hidden_act
								UpperCamelCase      =		hidden_dropout_prob
								UpperCamelCase      =		attention_probs_dropout_prob
								UpperCamelCase      =		max_position_embeddings
								UpperCamelCase      =		type_vocab_size
								UpperCamelCase      =		type_sequence_label_size
								UpperCamelCase      =		initializer_range
								UpperCamelCase      =		num_labels
								UpperCamelCase      =		num_choices
								UpperCamelCase      =		scope


						def 			snake_case_      (self						)       ->      int:
								UpperCamelCase      =		ids_tensor([self.batch_size, self.seq_length]      ,							self.vocab_size						)

								UpperCamelCase      =		None
								if self.use_input_mask:
										UpperCamelCase      =		random_attention_mask([self.batch_size, self.seq_length]						)

								UpperCamelCase      =		None
								if self.use_token_type_ids:
										UpperCamelCase      =		ids_tensor([self.batch_size, self.seq_length]      ,							self.type_vocab_size						)

								UpperCamelCase      =		None
								UpperCamelCase      =		None
								UpperCamelCase      =		None
								if self.use_labels:
										UpperCamelCase      =		ids_tensor([self.batch_size]      ,							self.type_sequence_label_size						)
										UpperCamelCase      =		ids_tensor([self.batch_size, self.seq_length]      ,							self.num_labels						)
										UpperCamelCase      =		ids_tensor([self.batch_size]      ,							self.num_choices						)

								UpperCamelCase      =		self.get_config()

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


						def 			snake_case_      (self						)       ->      List[Any]:
								return NezhaConfig(
								    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=__SCREAMING_SNAKE_CASE      ,							initializer_range=self.initializer_range      ,							)


						def 			snake_case_      (self						)       ->      List[str]:
								(
								    (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      ,    
								)      =		self.prepare_config_and_inputs()

								UpperCamelCase      =		True
								UpperCamelCase      =		floats_tensor([self.batch_size, self.seq_length, self.hidden_size]						)
								UpperCamelCase      =		ids_tensor([self.batch_size, self.seq_length]      ,							vocab_size=2						)

								return (
								    config,
								    input_ids,
								    token_type_ids,
								    input_mask,
								    sequence_labels,
								    token_labels,
								    choice_labels,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a						)       ->      Union[str, Any]:
								UpperCamelCase      =		NezhaModel(config=__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE						)
								UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE						)
								UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE						)
								self.parent.assertEqual(result.last_hidden_state.shape      ,							(self.batch_size, self.seq_length, self.hidden_size)						)
								self.parent.assertEqual(result.pooler_output.shape      ,							(self.batch_size, self.hidden_size)						)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							)       ->      Any:
								UpperCamelCase      =		True
								UpperCamelCase      =		NezhaModel(__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		model(
								    __SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							encoder_hidden_states=__SCREAMING_SNAKE_CASE      ,							encoder_attention_mask=__SCREAMING_SNAKE_CASE      ,							)
								UpperCamelCase      =		model(
								    __SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							encoder_hidden_states=__SCREAMING_SNAKE_CASE      ,							)
								UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE						)
								self.parent.assertEqual(result.last_hidden_state.shape      ,							(self.batch_size, self.seq_length, self.hidden_size)						)
								self.parent.assertEqual(result.pooler_output.shape      ,							(self.batch_size, self.hidden_size)						)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a						)       ->      Union[str, Any]:
								UpperCamelCase      =		NezhaForMaskedLM(config=__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							labels=__SCREAMING_SNAKE_CASE						)
								self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.seq_length, self.vocab_size)						)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a						)       ->      Tuple:
								UpperCamelCase      =		NezhaForNextSentencePrediction(config=__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		model(
								    __SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							labels=__SCREAMING_SNAKE_CASE      ,							)
								self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, 2)						)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a						)       ->      List[str]:
								UpperCamelCase      =		NezhaForPreTraining(config=__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		model(
								    __SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							labels=__SCREAMING_SNAKE_CASE      ,							next_sentence_label=__SCREAMING_SNAKE_CASE      ,							)
								self.parent.assertEqual(result.prediction_logits.shape      ,							(self.batch_size, self.seq_length, self.vocab_size)						)
								self.parent.assertEqual(result.seq_relationship_logits.shape      ,							(self.batch_size, 2)						)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a						)       ->      Dict:
								UpperCamelCase      =		NezhaForQuestionAnswering(config=__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		model(
								    __SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							start_positions=__SCREAMING_SNAKE_CASE      ,							end_positions=__SCREAMING_SNAKE_CASE      ,							)
								self.parent.assertEqual(result.start_logits.shape      ,							(self.batch_size, self.seq_length)						)
								self.parent.assertEqual(result.end_logits.shape      ,							(self.batch_size, self.seq_length)						)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a						)       ->      Union[str, Any]:
								UpperCamelCase      =		self.num_labels
								UpperCamelCase      =		NezhaForSequenceClassification(__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							labels=__SCREAMING_SNAKE_CASE						)
								self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.num_labels)						)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a						)       ->      Optional[int]:
								UpperCamelCase      =		self.num_labels
								UpperCamelCase      =		NezhaForTokenClassification(config=__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							labels=__SCREAMING_SNAKE_CASE						)
								self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.seq_length, self.num_labels)						)


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a      ,							__a						)       ->      int:
								UpperCamelCase      =		self.num_choices
								UpperCamelCase      =		NezhaForMultipleChoice(config=__SCREAMING_SNAKE_CASE						)
								model.to(__SCREAMING_SNAKE_CASE						)
								model.eval()
								UpperCamelCase      =		input_ids.unsqueeze(1						).expand(-1      ,							self.num_choices      ,							-1						).contiguous()
								UpperCamelCase      =		token_type_ids.unsqueeze(1						).expand(-1      ,							self.num_choices      ,							-1						).contiguous()
								UpperCamelCase      =		input_mask.unsqueeze(1						).expand(-1      ,							self.num_choices      ,							-1						).contiguous()
								UpperCamelCase      =		model(
								    __SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE      ,							token_type_ids=__SCREAMING_SNAKE_CASE      ,							labels=__SCREAMING_SNAKE_CASE      ,							)
								self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.num_choices)						)




						def 			snake_case_      (self						)       ->      List[Any]:
								UpperCamelCase      =		self.prepare_config_and_inputs()
								(
								    (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      ,    
								)      =		config_and_inputs
								UpperCamelCase      =		{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
								return config, inputs_dict





@require_torch
class 				_lowerCamelCase					(				__UpperCAmelCase     ,	__UpperCAmelCase     ,	__UpperCAmelCase     ,	unittest.TestCase       ):
						UpperCAmelCase_       =	(
						    (
						        NezhaModel,
						        NezhaForMaskedLM,
						        NezhaForMultipleChoice,
						        NezhaForNextSentencePrediction,
						        NezhaForPreTraining,
						        NezhaForQuestionAnswering,
						        NezhaForSequenceClassification,
						        NezhaForTokenClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCAmelCase_       =	(
						    {
						        '''feature-extraction''': NezhaModel,
						        '''fill-mask''': NezhaForMaskedLM,
						        '''question-answering''': NezhaForQuestionAnswering,
						        '''text-classification''': NezhaForSequenceClassification,
						        '''token-classification''': NezhaForTokenClassification,
						        '''zero-shot''': NezhaForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						UpperCAmelCase_       =	True


						def 			snake_case_      (self      ,							__a      ,							__a      ,							__a=False						)       ->      List[Any]:
								UpperCamelCase      =		super()._prepare_for_class(__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							return_labels=__SCREAMING_SNAKE_CASE						)

								if return_labels:
										if model_class in get_values(__SCREAMING_SNAKE_CASE						):
												UpperCamelCase      =		torch.zeros(
												    (self.model_tester.batch_size, self.model_tester.seq_length)      ,							dtype=torch.long      ,							device=__SCREAMING_SNAKE_CASE						)
												UpperCamelCase      =		torch.zeros(
												    self.model_tester.batch_size      ,							dtype=torch.long      ,							device=__SCREAMING_SNAKE_CASE						)
								return inputs_dict


						def 			snake_case_      (self						)       ->      List[Any]:
								UpperCamelCase      =		NezhaModelTester(self						)
								UpperCamelCase      =		ConfigTester(self      ,							config_class=__SCREAMING_SNAKE_CASE      ,							hidden_size=37						)


						def 			snake_case_      (self						)       ->      List[Any]:
								self.config_tester.run_common_tests()


						def 			snake_case_      (self						)       ->      List[Any]:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE						)


						def 			snake_case_      (self						)       ->      List[Any]:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs_for_decoder()
								self.model_tester.create_and_check_model_as_decoder(*__SCREAMING_SNAKE_CASE						)


						def 			snake_case_      (self						)       ->      Any:
								(
								    (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      , (
								    UpperCamelCase   
								)      ,    
								)      =		self.model_tester.prepare_config_and_inputs_for_decoder()

								UpperCamelCase      =		None

								self.model_tester.create_and_check_model_as_decoder(
								    __SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE      ,							)


						def 			snake_case_      (self						)       ->      Union[str, Any]:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE						)


						def 			snake_case_      (self						)       ->      int:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE						)


						def 			snake_case_      (self						)       ->      Optional[Any]:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_next_sequence_prediction(*__SCREAMING_SNAKE_CASE						)


						def 			snake_case_      (self						)       ->      List[Any]:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_pretraining(*__SCREAMING_SNAKE_CASE						)


						def 			snake_case_      (self						)       ->      Union[str, Any]:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE						)


						def 			snake_case_      (self						)       ->      Optional[Any]:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE						)


						def 			snake_case_      (self						)       ->      List[str]:
								UpperCamelCase      =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE						)


						@slow
						def 			snake_case_      (self						)       ->      List[str]:

								for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										UpperCamelCase      =		NezhaModel.from_pretrained(__SCREAMING_SNAKE_CASE						)
										self.assertIsNotNone(__SCREAMING_SNAKE_CASE						)




						@slow
						@require_torch_gpu
						def 			snake_case_      (self						)       ->      List[Any]:
								UpperCamelCase      , UpperCamelCase      =		self.model_tester.prepare_config_and_inputs_for_common()
								for model_class in self.all_model_classes:
										# NezhaForMultipleChoice behaves incorrectly in JIT environments.
										if model_class == NezhaForMultipleChoice:
												return

										UpperCamelCase      =		True
										UpperCamelCase      =		model_class(config=__SCREAMING_SNAKE_CASE						)

										UpperCamelCase      =		self._prepare_for_class(__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE						)
										UpperCamelCase      =		torch.jit.trace(
										    __SCREAMING_SNAKE_CASE      ,							(inputs_dict["input_ids"].to("cpu"						), inputs_dict["attention_mask"].to("cpu"						))						)

										with tempfile.TemporaryDirectory() as tmp:
												torch.jit.save(__SCREAMING_SNAKE_CASE      ,							os.path.join(__SCREAMING_SNAKE_CASE      ,							"bert.pt"						)						)
												UpperCamelCase      =		torch.jit.load(os.path.join(__SCREAMING_SNAKE_CASE      ,							"bert.pt"						)      ,							map_location=__SCREAMING_SNAKE_CASE						)
												loaded(inputs_dict["input_ids"].to(__SCREAMING_SNAKE_CASE						)      ,							inputs_dict["attention_mask"].to(__SCREAMING_SNAKE_CASE						)						)





@require_torch
class 				_lowerCamelCase					(				unittest.TestCase       ):


						@slow
						def 			snake_case_      (self						)       ->      Optional[int]:
								UpperCamelCase      =		NezhaModel.from_pretrained("sijunhe/nezha-cn-base"						)
								UpperCamelCase      =		torch.tensor([[0, 1, 2, 3, 4, 5]]						)
								UpperCamelCase      =		torch.tensor([[0, 1, 1, 1, 1, 1]]						)
								with torch.no_grad():
										UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE						)[0]
								UpperCamelCase      =		torch.Size((1, 6, 7_68)						)
								self.assertEqual(output.shape      ,							__SCREAMING_SNAKE_CASE						)
								UpperCamelCase      =		torch.tensor([[[0.0685, 0.2441, 0.1102], [0.0600, 0.1906, 0.1349], [0.0221, 0.0819, 0.0586]]]						)

								self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,							__SCREAMING_SNAKE_CASE      ,							atol=1e-4						)						)




						@slow
						def 			snake_case_      (self						)       ->      str:
								UpperCamelCase      =		NezhaForMaskedLM.from_pretrained("sijunhe/nezha-cn-base"						)
								UpperCamelCase      =		torch.tensor([[0, 1, 2, 3, 4, 5]]						)
								UpperCamelCase      =		torch.tensor([[1, 1, 1, 1, 1, 1]]						)
								with torch.no_grad():
										UpperCamelCase      =		model(__SCREAMING_SNAKE_CASE      ,							attention_mask=__SCREAMING_SNAKE_CASE						)[0]
								UpperCamelCase      =		torch.Size((1, 6, 2_11_28)						)
								self.assertEqual(output.shape      ,							__SCREAMING_SNAKE_CASE						)
								UpperCamelCase      =		torch.tensor(
								    [[-2.7939, -1.7902, -2.2189], [-2.8585, -1.8908, -2.3723], [-2.6499, -1.7750, -2.2558]]						)

								self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,							__SCREAMING_SNAKE_CASE      ,							atol=1e-4						)						)











import copy
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, Optional, Union

@dataclass
class     _A       :
       UpperCamelCase__  :    Optional[Union[str, Path]]											=						None
       UpperCamelCase__  :    bool											=						False
       UpperCamelCase__  :    bool											=						False
       UpperCamelCase__  :    bool											=						False
       UpperCamelCase__  :    Optional[Dict]											=						None
       UpperCamelCase__  :    Optional[str]											=						None
       UpperCamelCase__  :    bool											=						False
       UpperCamelCase__  :    bool											=						False
       UpperCamelCase__  :    bool											=						False
       UpperCamelCase__  :    bool											=						True
       UpperCamelCase__  :    Optional[int]											=						None
       UpperCamelCase__  :    int											=						1
       UpperCamelCase__  :    Optional[Union[str, bool]]											=						None
       UpperCamelCase__  :    bool											=						False
       UpperCamelCase__  :    Optional[Dict]											=						None
       UpperCamelCase__  :    Optional[str]											=						None



       def 		_lowerCamelCase			(		self							:     Union[str, Any]):


           '''simple docstring'''

           return self.__class__(**{k: copy.deepcopy(__SCREAMING_SNAKE_CASE) for k, v in self.__dict__.items()})





