






import unittest

from transformers import DebertaVaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     DebertaVaForMaskedLM,
     DebertaVaForMultipleChoice,
     DebertaVaForQuestionAnswering,
     DebertaVaForSequenceClassification,
     DebertaVaForTokenClassification,
     DebertaVaModel,
 )
 from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST







class 			UpperCAmelCase_						(					lowercase ):



      """simple docstring"""
      def __init__(				self    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_=13    ,				SCREAMING_SNAKE_CASE_=7    ,				SCREAMING_SNAKE_CASE_=True    ,				SCREAMING_SNAKE_CASE_=True    ,				SCREAMING_SNAKE_CASE_=True    ,				SCREAMING_SNAKE_CASE_=True    ,				SCREAMING_SNAKE_CASE_=99    ,				SCREAMING_SNAKE_CASE_=32    ,				SCREAMING_SNAKE_CASE_=5    ,				SCREAMING_SNAKE_CASE_=4    ,				SCREAMING_SNAKE_CASE_=37    ,				SCREAMING_SNAKE_CASE_="gelu"    ,				SCREAMING_SNAKE_CASE_=0.1    ,				SCREAMING_SNAKE_CASE_=0.1    ,				SCREAMING_SNAKE_CASE_=512    ,				SCREAMING_SNAKE_CASE_=16    ,				SCREAMING_SNAKE_CASE_=2    ,				SCREAMING_SNAKE_CASE_=0.02    ,				SCREAMING_SNAKE_CASE_=False    ,				SCREAMING_SNAKE_CASE_=True    ,				SCREAMING_SNAKE_CASE_="None"    ,				SCREAMING_SNAKE_CASE_=3    ,				SCREAMING_SNAKE_CASE_=4    ,				SCREAMING_SNAKE_CASE_=None    ,				)				->      List[Any]:
          UpperCamelCase       :Any								=   parent
          UpperCamelCase       :str								=   batch_size
          UpperCamelCase       :Any								=   seq_length
          UpperCamelCase       :int								=   is_training
          UpperCamelCase       :int								=   use_input_mask
          UpperCamelCase       :List[str]								=   use_token_type_ids
          UpperCamelCase       :List[Any]								=   use_labels
          UpperCamelCase       :str								=   vocab_size
          UpperCamelCase       :Dict								=   hidden_size
          UpperCamelCase       :Optional[int]								=   num_hidden_layers
          UpperCamelCase       :str								=   num_attention_heads
          UpperCamelCase       :Optional[Any]								=   intermediate_size
          UpperCamelCase       :List[Any]								=   hidden_act
          UpperCamelCase       :Union[str, Any]								=   hidden_dropout_prob
          UpperCamelCase       :Optional[Any]								=   attention_probs_dropout_prob
          UpperCamelCase       :Union[str, Any]								=   max_position_embeddings
          UpperCamelCase       :Optional[int]								=   type_vocab_size
          UpperCamelCase       :Dict								=   type_sequence_label_size
          UpperCamelCase       :Optional[int]								=   initializer_range
          UpperCamelCase       :Optional[int]								=   num_labels
          UpperCamelCase       :int								=   num_choices
          UpperCamelCase       :List[Any]								=   relative_attention
          UpperCamelCase       :str								=   position_biased_input
          UpperCamelCase       :Optional[Any]								=   pos_att_type
          UpperCamelCase       :List[str]								=   scope
      def     UpperCAmelCase						(				self )				->      str:
          UpperCamelCase       :List[Any]								=   ids_tensor([self.batch_size, self.seq_length]    ,				self.vocab_size )

          UpperCamelCase       :Union[str, Any]								=   None
          if self.use_input_mask:
              UpperCamelCase       :Dict								=   ids_tensor([self.batch_size, self.seq_length]    ,				vocab_size=2 )

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

          UpperCamelCase       :Dict								=   None
          UpperCamelCase       :Optional[int]								=   None
          UpperCamelCase       :List[str]								=   None
          if self.use_labels:
              UpperCamelCase       :Any								=   ids_tensor([self.batch_size]    ,				self.type_sequence_label_size )
              UpperCamelCase       :Tuple								=   ids_tensor([self.batch_size, self.seq_length]    ,				self.num_labels )
              UpperCamelCase       :List[Any]								=   ids_tensor([self.batch_size]    ,				self.num_choices )

          UpperCamelCase       :Optional[int]								=   self.get_config()

          return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
      def     UpperCAmelCase						(				self )				->      str:
          return DebertaVaConfig(
              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    ,				initializer_range=self.initializer_range    ,				relative_attention=self.relative_attention    ,				position_biased_input=self.position_biased_input    ,				pos_att_type=self.pos_att_type    ,				)
      def     UpperCAmelCase						(				self    ,				SCREAMING_SNAKE_CASE_ )				->      Union[str, Any]:
          self.parent.assertListEqual(list(result.loss.size() )    ,				[] )
      def     UpperCAmelCase						(				self    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_ )				->      str:
          UpperCamelCase       :Union[str, Any]								=   DebertaVaModel(config=__lowerCAmelCase )
          model.to(__lowerCAmelCase )
          model.eval()
          UpperCamelCase       :List[Any]								=   model(__lowerCAmelCase    ,				attention_mask=__lowerCAmelCase    ,				token_type_ids=__lowerCAmelCase )[0]
          UpperCamelCase       :List[Any]								=   model(__lowerCAmelCase    ,				token_type_ids=__lowerCAmelCase )[0]
          UpperCamelCase       :Tuple								=   model(__lowerCAmelCase )[0]

          self.parent.assertListEqual(list(sequence_output.size() )    ,				[self.batch_size, self.seq_length, self.hidden_size] )
      def     UpperCAmelCase						(				self    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_ )				->      Tuple:
          UpperCamelCase       :Dict								=   DebertaVaForMaskedLM(config=__lowerCAmelCase )
          model.to(__lowerCAmelCase )
          model.eval()
          UpperCamelCase       :Optional[Any]								=   model(__lowerCAmelCase    ,				attention_mask=__lowerCAmelCase    ,				token_type_ids=__lowerCAmelCase    ,				labels=__lowerCAmelCase )

          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.seq_length, self.vocab_size) )
      def     UpperCAmelCase						(				self    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_ )				->      List[str]:
          UpperCamelCase       :str								=   self.num_labels
          UpperCamelCase       :Any								=   DebertaVaForSequenceClassification(__lowerCAmelCase )
          model.to(__lowerCAmelCase )
          model.eval()
          UpperCamelCase       :str								=   model(__lowerCAmelCase    ,				attention_mask=__lowerCAmelCase    ,				token_type_ids=__lowerCAmelCase    ,				labels=__lowerCAmelCase )
          self.parent.assertListEqual(list(result.logits.size() )    ,				[self.batch_size, self.num_labels] )
          self.check_loss_output(__lowerCAmelCase )
      def     UpperCAmelCase						(				self    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_ )				->      Tuple:
          UpperCamelCase       :List[str]								=   self.num_labels
          UpperCamelCase       :Optional[int]								=   DebertaVaForTokenClassification(config=__lowerCAmelCase )
          model.to(__lowerCAmelCase )
          model.eval()
          UpperCamelCase       :Optional[int]								=   model(__lowerCAmelCase    ,				attention_mask=__lowerCAmelCase    ,				token_type_ids=__lowerCAmelCase    ,				labels=__lowerCAmelCase )
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.seq_length, self.num_labels) )
      def     UpperCAmelCase						(				self    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_ )				->      Any:
          UpperCamelCase       :Union[str, Any]								=   DebertaVaForQuestionAnswering(config=__lowerCAmelCase )
          model.to(__lowerCAmelCase )
          model.eval()
          UpperCamelCase       :Optional[int]								=   model(
              __lowerCAmelCase    ,				attention_mask=__lowerCAmelCase    ,				token_type_ids=__lowerCAmelCase    ,				start_positions=__lowerCAmelCase    ,				end_positions=__lowerCAmelCase    ,				)
          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     UpperCAmelCase						(				self    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_    ,				SCREAMING_SNAKE_CASE_ )				->      Dict:
          UpperCamelCase       :int								=   DebertaVaForMultipleChoice(config=__lowerCAmelCase )
          model.to(__lowerCAmelCase )
          model.eval()
          UpperCamelCase       :Any								=   input_ids.unsqueeze(1 ).expand(-1    ,				self.num_choices    ,				-1 ).contiguous()
          UpperCamelCase       :str								=   token_type_ids.unsqueeze(1 ).expand(-1    ,				self.num_choices    ,				-1 ).contiguous()
          UpperCamelCase       :Any								=   input_mask.unsqueeze(1 ).expand(-1    ,				self.num_choices    ,				-1 ).contiguous()
          UpperCamelCase       :Optional[Any]								=   model(
              __lowerCAmelCase    ,				attention_mask=__lowerCAmelCase    ,				token_type_ids=__lowerCAmelCase    ,				labels=__lowerCAmelCase    ,				)
          self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.num_choices) )




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







@require_torch
class 			UpperCAmelCase_						(					lowercase,	lowercase,	unittest.TestCase ):



      """simple docstring"""
      UpperCamelCase_				:					List[str]           =(
          (
              DebertaVaModel,
              DebertaVaForMaskedLM,
              DebertaVaForSequenceClassification,
              DebertaVaForTokenClassification,
              DebertaVaForQuestionAnswering,
              DebertaVaForMultipleChoice,
          )
          if is_torch_available()
          else ()
      )
      UpperCamelCase_				:					Union[str, Any]           =(
          {
              'feature-extraction': DebertaVaModel,
              'fill-mask': DebertaVaForMaskedLM,
              'question-answering': DebertaVaForQuestionAnswering,
              'text-classification': DebertaVaForSequenceClassification,
              'token-classification': DebertaVaForTokenClassification,
              'zero-shot': DebertaVaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )

      UpperCamelCase_				:					Union[str, Any]           =True
      UpperCamelCase_				:					Tuple           =False
      UpperCamelCase_				:					List[Any]           =False
      UpperCamelCase_				:					Dict           =False
      UpperCamelCase_				:					Union[str, Any]           =False
      def     UpperCAmelCase						(				self )				->      Any:
          UpperCamelCase       :Tuple								=   DebertaVaModelTester(self )
          UpperCamelCase       :Union[str, Any]								=   ConfigTester(self    ,				config_class=__lowerCAmelCase    ,				hidden_size=37 )
      def     UpperCAmelCase						(				self )				->      List[str]:
          self.config_tester.run_common_tests()
      def     UpperCAmelCase						(				self )				->      Union[str, Any]:
          UpperCamelCase       :str								=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_deberta_model(*__lowerCAmelCase )
      def     UpperCAmelCase						(				self )				->      Any:
          UpperCamelCase       :Union[str, Any]								=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_deberta_for_sequence_classification(*__lowerCAmelCase )
      def     UpperCAmelCase						(				self )				->      str:
          UpperCamelCase       :List[Any]								=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_deberta_for_masked_lm(*__lowerCAmelCase )
      def     UpperCAmelCase						(				self )				->      str:
          UpperCamelCase       :Union[str, Any]								=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_deberta_for_question_answering(*__lowerCAmelCase )
      def     UpperCAmelCase						(				self )				->      Tuple:
          UpperCamelCase       :Optional[int]								=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_deberta_for_token_classification(*__lowerCAmelCase )
      def     UpperCAmelCase						(				self )				->      Optional[Any]:
          UpperCamelCase       :List[Any]								=   self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_deberta_for_multiple_choice(*__lowerCAmelCase )




      @slow
      def     UpperCAmelCase						(				self )				->      Optional[int]:







          for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCamelCase       :List[Any]								=   DebertaVaModel.from_pretrained(__lowerCAmelCase )
              self.assertIsNotNone(__lowerCAmelCase )







@require_torch
@require_sentencepiece
@require_tokenizers
class 			UpperCAmelCase_						(					unittest.TestCase ):



      """simple docstring"""
      @unittest.skip(reason='''Model not available yet''' )
      def     UpperCAmelCase						(				self )				->      List[Any]:
          pass




      @slow
      def     UpperCAmelCase						(				self )				->      Optional[int]:
          UpperCamelCase       :str								=   DebertaVaModel.from_pretrained('''microsoft/deberta-v2-xlarge''' )

          UpperCamelCase       :Dict								=   torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]] )
          UpperCamelCase       :Dict								=   torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
          with torch.no_grad():
              UpperCamelCase       :Union[str, Any]								=   model(__lowerCAmelCase    ,				attention_mask=__lowerCAmelCase )[0]
          # compare the actual values for a slice.
          UpperCamelCase       :Union[str, Any]								=   torch.tensor(
              [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]] )
          self.assertTrue(torch.allclose(output[:, 1:4, 1:4]    ,				__lowerCAmelCase    ,				atol=1e-4 )    ,				F'''{output[:, 1:4, 1:4]}''' )












import torch

from diffusers import UnCLIPScheduler

from .test_schedulers import SchedulerCommonTest






class 					__A    (    lowerCAmelCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						(UnCLIPScheduler,)





			def 		__lowerCamelCase				(    self       ,  **__lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__								=		{
				    '''num_train_timesteps''': 1_0_0_0,
				    '''variance_type''': '''fixed_small_log''',
				    '''clip_sample''': True,
				    '''clip_sample_range''': 1.0,
				    '''prediction_type''': '''epsilon''',
				}

				config.update(**__lowerCAmelCase							)
				return config





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				for timesteps in [1, 5, 1_0_0, 1_0_0_0]:
					self.check_over_configs(num_train_timesteps=__lowerCAmelCase							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				for variance in ["fixed_small_log", "learned_range"]:
					self.check_over_configs(variance_type=__lowerCAmelCase							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				for clip_sample in [True, False]:
					self.check_over_configs(clip_sample=__lowerCAmelCase							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				for clip_sample_range in [1, 5, 1_0, 2_0]:
					self.check_over_configs(clip_sample_range=__lowerCAmelCase							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				for prediction_type in ["epsilon", "sample"]:
					self.check_over_configs(prediction_type=__lowerCAmelCase							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				for time_step in [0, 5_0_0, 9_9_9]:
					for prev_timestep in [None, 5, 1_0_0, 2_5_0, 5_0_0, 7_5_0]:
						if prev_timestep is not None and prev_timestep >= time_step:
							continue

						self.check_over_forward(time_step=__lowerCAmelCase       ,  prev_timestep=__lowerCAmelCase							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.scheduler_classes[0]
				lowerCamelCase__								=		self.get_scheduler_config(variance_type='''fixed_small_log'''							)
				lowerCamelCase__								=		scheduler_class(**__lowerCAmelCase							)

				assert torch.sum(torch.abs(scheduler._get_variance(0							) - 1.0000E-10							)							) < 1E-5
				assert torch.sum(torch.abs(scheduler._get_variance(4_8_7							) - 0.054_9625							)							) < 1E-5
				assert torch.sum(torch.abs(scheduler._get_variance(9_9_9							) - 0.999_4987							)							) < 1E-5





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.scheduler_classes[0]
				lowerCamelCase__								=		self.get_scheduler_config(variance_type='''learned_range'''							)
				lowerCamelCase__								=		scheduler_class(**__lowerCAmelCase							)

				lowerCamelCase__								=		0.5

				assert scheduler._get_variance(1       ,  predicted_variance=__lowerCAmelCase							) - -10.171_2790 < 1E-5
				assert scheduler._get_variance(4_8_7       ,  predicted_variance=__lowerCAmelCase							) - -5.799_8052 < 1E-5
				assert scheduler._get_variance(9_9_9       ,  predicted_variance=__lowerCAmelCase							) - -0.001_0011 < 1E-5





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.scheduler_classes[0]
				lowerCamelCase__								=		self.get_scheduler_config()
				lowerCamelCase__								=		scheduler_class(**__lowerCAmelCase							)

				lowerCamelCase__								=		scheduler.timesteps

				lowerCamelCase__								=		self.dummy_model()
				lowerCamelCase__								=		self.dummy_sample_deter
				lowerCamelCase__								=		torch.manual_seed(0							)

				for i, t in enumerate(__lowerCAmelCase							):
					# 1. predict noise residual
					lowerCamelCase__								=		model(__lowerCAmelCase       ,  __lowerCAmelCase							)

					# 2. predict previous mean of sample x_t-1
					lowerCamelCase__								=		scheduler.step(__lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  generator=__lowerCAmelCase							).prev_sample

					lowerCamelCase__								=		pred_prev_sample

				lowerCamelCase__								=		torch.sum(torch.abs(__lowerCAmelCase							)							)
				lowerCamelCase__								=		torch.mean(torch.abs(__lowerCAmelCase							)							)

				assert abs(result_sum.item() - 252.268_2495							) < 1E-2
				assert abs(result_mean.item() - 0.328_4743							) < 1E-3





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.scheduler_classes[0]
				lowerCamelCase__								=		self.get_scheduler_config()
				lowerCamelCase__								=		scheduler_class(**__lowerCAmelCase							)

				scheduler.set_timesteps(2_5							)

				lowerCamelCase__								=		scheduler.timesteps

				lowerCamelCase__								=		self.dummy_model()
				lowerCamelCase__								=		self.dummy_sample_deter
				lowerCamelCase__								=		torch.manual_seed(0							)

				for i, t in enumerate(__lowerCAmelCase							):
					# 1. predict noise residual
					lowerCamelCase__								=		model(__lowerCAmelCase       ,  __lowerCAmelCase							)

					if i + 1 == timesteps.shape[0]:
						lowerCamelCase__								=		None
					else:
						lowerCamelCase__								=		timesteps[i + 1]

					# 2. predict previous mean of sample x_t-1
					lowerCamelCase__								=		scheduler.step(
					    __lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  prev_timestep=__lowerCAmelCase       ,  generator=__lowerCAmelCase							).prev_sample

					lowerCamelCase__								=		pred_prev_sample

				lowerCamelCase__								=		torch.sum(torch.abs(__lowerCAmelCase							)							)
				lowerCamelCase__								=		torch.mean(torch.abs(__lowerCAmelCase							)							)

				assert abs(result_sum.item() - 258.204_4983							) < 1E-2
				assert abs(result_mean.item() - 0.336_2038							) < 1E-3





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				pass





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				pass



