

from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
     from ...feature_extraction_utils import FeatureExtractionMixin
     from ...tokenization_utils_base import PreTrainedTokenizerBase
     from ...utils import TensorType

_lowerCamelCase    :       Dict        =							logging.get_logger(__name__)

_lowerCamelCase    :       Dict        =							{
    "openai/whisper-base": "https://huggingface.co/openai/whisper-base/resolve/main/config.json",
}

# fmt: off
_lowerCamelCase    :       Optional[int]        =							[
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_7, 3_6_6, 4_3_8, 5_3_2, 6_8_5,
    7_0_5, 7_9_6, 9_3_0, 1_0_5_8, 1_2_2_0, 1_2_6_7, 1_2_7_9, 1_3_0_3, 1_3_4_3, 1_3_7_7,
    1_3_9_1, 1_6_3_5, 1_7_8_2, 1_8_7_5, 2_1_6_2, 2_3_6_1, 2_4_8_8, 3_4_6_7, 4_0_0_8, 4_2_1_1,
    4_6_0_0, 4_8_0_8, 5_2_9_9, 5_8_5_5, 6_3_2_9, 7_2_0_3, 9_6_0_9, 9_9_5_9, 1_0_5_6_3, 1_0_7_8_6,
    1_1_4_2_0, 1_1_7_0_9, 1_1_9_0_7, 1_3_1_6_3, 1_3_6_9_7, 1_3_7_0_0, 1_4_8_0_8, 1_5_3_0_6, 1_6_4_1_0, 1_6_7_9_1,
    1_7_9_9_2, 1_9_2_0_3, 1_9_5_1_0, 2_0_7_2_4, 2_2_3_0_5, 2_2_9_3_5, 2_7_0_0_7, 3_0_1_0_9, 3_0_4_2_0, 3_3_4_0_9,
    3_4_9_4_9, 4_0_2_8_3, 4_0_4_9_3, 4_0_5_4_9, 4_7_2_8_2, 4_9_1_4_6, 5_0_2_5_7, 5_0_3_5_9, 5_0_3_6_0, 5_0_3_6_1
]
_lowerCamelCase    :       int        =							[
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_9, 5_0_3, 5_2_2, 5_4_2, 8_7_3,
    8_9_3, 9_0_2, 9_1_8, 9_2_2, 9_3_1, 1_3_5_0, 1_8_5_3, 1_9_8_2, 2_4_6_0, 2_6_2_7,
    3_2_4_6, 3_2_5_3, 3_2_6_8, 3_5_3_6, 3_8_4_6, 3_9_6_1, 4_1_8_3, 4_6_6_7, 6_5_8_5, 6_6_4_7,
    7_2_7_3, 9_0_6_1, 9_3_8_3, 1_0_4_2_8, 1_0_9_2_9, 1_1_9_3_8, 1_2_0_3_3, 1_2_3_3_1, 1_2_5_6_2, 1_3_7_9_3,
    1_4_1_5_7, 1_4_6_3_5, 1_5_2_6_5, 1_5_6_1_8, 1_6_5_5_3, 1_6_6_0_4, 1_8_3_6_2, 1_8_9_5_6, 2_0_0_7_5, 2_1_6_7_5,
    2_2_5_2_0, 2_6_1_3_0, 2_6_1_6_1, 2_6_4_3_5, 2_8_2_7_9, 2_9_4_6_4, 3_1_6_5_0, 3_2_3_0_2, 3_2_4_7_0, 3_6_8_6_5,
    4_2_8_6_3, 4_7_4_2_5, 4_9_8_7_0, 5_0_2_5_4, 5_0_2_5_8, 5_0_3_6_0, 5_0_3_6_1, 5_0_3_6_2
]





class  __UpperCAmelCase					(	lowerCamelCase__						):
   UpperCamelCase       					=					"""whisper"""
   UpperCamelCase       					=					["""past_key_values"""]
   UpperCamelCase       					=					{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}



   def __init__(							self							:					Dict,		__A							:					str=5_1_8_6_5,		__A							:					str=8_0,		__A							:					Union[str, Any]=6,		__A							:					Tuple=4,		__A							:					int=6,		__A							:					Dict=4,		__A							:					str=1_5_3_6,		__A							:					List[Any]=1_5_3_6,		__A							:					str=0.0,		__A							:					Tuple=0.0,		__A							:					Optional[int]=5_0_2_5_7,		__A							:					Dict=True,		__A							:					Any=True,		__A							:					Any="gelu",		__A							:					List[Any]=2_5_6,		__A							:					List[str]=0.0,		__A							:					Optional[int]=0.0,		__A							:					str=0.0,		__A							:					Optional[int]=0.0_2,		__A							:					Optional[int]=False,		__A							:					int=1_5_0_0,		__A							:					Optional[Any]=4_4_8,		__A							:					Optional[Any]=5_0_2_5_6,		__A							:					List[Any]=5_0_2_5_6,		__A							:					Optional[Any]=5_0_2_5_6,		__A							:					List[Any]=None,		__A							:					List[str]=[2_2_0, 5_0_2_5_6],		__A							:					Union[str, Any]=False,		__A							:					Union[str, Any]=2_5_6,		__A							:					List[str]=False,		__A							:					Optional[Any]=0.0_5,		__A							:					Any=1_0,		__A							:					Union[str, Any]=2,		__A							:					Tuple=0.0,		__A							:					Tuple=1_0,		__A							:					Optional[Any]=0,		__A							:					List[str]=7,		**__A							:					Dict,		):
     UpperCAmelCase	:							Optional[Any]						=			vocab_size
     UpperCAmelCase	:							int						=			num_mel_bins
     UpperCAmelCase	:							Dict						=			d_model
     UpperCAmelCase	:							Dict						=			encoder_layers
     UpperCAmelCase	:							Union[str, Any]						=			encoder_attention_heads
     UpperCAmelCase	:							List[str]						=			decoder_layers
     UpperCAmelCase	:							Dict						=			decoder_attention_heads
     UpperCAmelCase	:							Dict						=			decoder_ffn_dim
     UpperCAmelCase	:							List[str]						=			encoder_ffn_dim
     UpperCAmelCase	:							Dict						=			dropout
     UpperCAmelCase	:							List[Any]						=			attention_dropout
     UpperCAmelCase	:							Tuple						=			activation_dropout
     UpperCAmelCase	:							Optional[int]						=			activation_function
     UpperCAmelCase	:							str						=			init_std
     UpperCAmelCase	:							List[str]						=			encoder_layerdrop
     UpperCAmelCase	:							str						=			decoder_layerdrop
     UpperCAmelCase	:							List[Any]						=			use_cache
     UpperCAmelCase	:							Tuple						=			encoder_layers
     UpperCAmelCase	:							str						=			scale_embedding  # scale factor will be sqrt(d_model) if True
     UpperCAmelCase	:							Dict						=			max_source_positions
     UpperCAmelCase	:							Dict						=			max_target_positions

     # Audio Classification-specific parameters. Feel free to ignore for other classes.
     UpperCAmelCase	:							int						=			classifier_proj_size
     UpperCAmelCase	:							Tuple						=			use_weighted_layer_sum

     # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
     UpperCAmelCase	:							str						=			apply_spec_augment
     UpperCAmelCase	:							str						=			mask_time_prob
     UpperCAmelCase	:							int						=			mask_time_length
     UpperCAmelCase	:							str						=			mask_time_min_masks
     UpperCAmelCase	:							Dict						=			mask_feature_prob
     UpperCAmelCase	:							Dict						=			mask_feature_length
     UpperCAmelCase	:							Union[str, Any]						=			mask_feature_min_masks

     UpperCAmelCase	:							Dict						=			median_filter_width

     super().__init__(
         pad_token_id=__A,		bos_token_id=__A,		eos_token_id=__A,		is_encoder_decoder=__A,		decoder_start_token_id=__A,		suppress_tokens=__A,		begin_suppress_tokens=__A,		**__A,		)






class  __UpperCAmelCase					(	lowerCamelCase__						):



   @property
   def 	__magic_name__   (							self							:					Tuple						):
     UpperCAmelCase	:							Optional[Any]						=			OrderedDict(
         [
             ('''input_features''', {0: '''batch''', 1: '''feature_size''', 2: '''encoder_sequence'''}),
         ]						)
     if self.use_past:
       UpperCAmelCase	:							Dict						=			{0: '''batch'''}
     else:
       UpperCAmelCase	:							Optional[Any]						=			{0: '''batch''', 1: '''decoder_sequence'''}

     if self.use_past:
       self.fill_with_past_key_values_(__A,		direction='''inputs'''						)

     return common_inputs



   def 	__magic_name__   (							self							:					List[str],		__A							:					Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"],		__A							:					int = -1,		__A							:					int = -1,		__A							:					bool = False,		__A							:					Optional["TensorType"] = None,		__A							:					int = 2_2_0_5_0,		__A							:					float = 5.0,		__A							:					int = 2_2_0,		):
     UpperCAmelCase	:							Optional[Any]						=			OrderedDict()
     UpperCAmelCase	:							Optional[int]						=			OnnxConfig.generate_dummy_inputs(
         self,		preprocessor=preprocessor.feature_extractor,		batch_size=__A,		framework=__A,		sampling_rate=__A,		time_duration=__A,		frequency=__A,		)
     UpperCAmelCase	:							Dict						=			encoder_inputs['''input_features'''].shape[2]
     UpperCAmelCase	:							Tuple						=			encoder_sequence_length // 2 if self.use_past else seq_length

     UpperCAmelCase	:							Optional[Any]						=			super().generate_dummy_inputs(
         preprocessor.tokenizer,		__A,		__A,		__A,		__A						)

     UpperCAmelCase	:							Tuple						=			encoder_inputs.pop('''input_features'''						)
     UpperCAmelCase	:							List[str]						=			decoder_inputs.pop('''decoder_input_ids'''						)

     if "past_key_values" in decoder_inputs:
       UpperCAmelCase	:							Optional[int]						=			decoder_inputs.pop('''past_key_values'''						)

     return dummy_inputs





   @property
   def 	__magic_name__   (							self							:					List[Any]						):
     return 1E-3








import inspect
import unittest

from transformers import BitConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import BitBackbone, BitForImageClassification, BitImageProcessor, BitModel
     from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image





class  __UpperCAmelCase					:



   def __init__(							self							:					Any,		__A							:					Optional[Any],		__A							:					Optional[Any]=3,		__A							:					Union[str, Any]=3_2,		__A							:					Optional[int]=3,		__A							:					str=1_0,		__A							:					Union[str, Any]=[8, 1_6, 3_2, 6_4],		__A							:					List[str]=[1, 1, 2, 1],		__A							:					Dict=True,		__A							:					List[Any]=True,		__A							:					int="relu",		__A							:					Optional[Any]=3,		__A							:					Any=None,		__A							:					Any=["stage2", "stage3", "stage4"],		__A							:					Optional[int]=[2, 3, 4],		__A							:					Any=1,		):
     UpperCAmelCase	:							Optional[int]						=			parent
     UpperCAmelCase	:							Union[str, Any]						=			batch_size
     UpperCAmelCase	:							Optional[int]						=			image_size
     UpperCAmelCase	:							List[Any]						=			num_channels
     UpperCAmelCase	:							Optional[Any]						=			embeddings_size
     UpperCAmelCase	:							List[Any]						=			hidden_sizes
     UpperCAmelCase	:							Any						=			depths
     UpperCAmelCase	:							int						=			is_training
     UpperCAmelCase	:							Optional[int]						=			use_labels
     UpperCAmelCase	:							Optional[Any]						=			hidden_act
     UpperCAmelCase	:							Any						=			num_labels
     UpperCAmelCase	:							List[Any]						=			scope
     UpperCAmelCase	:							int						=			len(__A						)
     UpperCAmelCase	:							Union[str, Any]						=			out_features
     UpperCAmelCase	:							List[str]						=			out_indices
     UpperCAmelCase	:							Tuple						=			num_groups



   def 	__magic_name__   (							self							:					Union[str, Any]						):
     UpperCAmelCase	:							Any						=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

     UpperCAmelCase	:							Dict						=			None
     if self.use_labels:
       UpperCAmelCase	:							List[str]						=			ids_tensor([self.batch_size],		self.num_labels						)

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

     return config, pixel_values, labels



   def 	__magic_name__   (							self							:					Tuple						):
     return BitConfig(
         num_channels=self.num_channels,		embeddings_size=self.embeddings_size,		hidden_sizes=self.hidden_sizes,		depths=self.depths,		hidden_act=self.hidden_act,		num_labels=self.num_labels,		out_features=self.out_features,		out_indices=self.out_indices,		num_groups=self.num_groups,		)



   def 	__magic_name__   (							self							:					int,		__A							:					str,		__A							:					List[Any],		__A							:					Any						):
     UpperCAmelCase	:							Optional[int]						=			BitModel(config=__A						)
     model.to(__A						)
     model.eval()
     UpperCAmelCase	:							Optional[int]						=			model(__A						)
     self.parent.assertEqual(
         result.last_hidden_state.shape,		(self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2),		)



   def 	__magic_name__   (							self							:					List[Any],		__A							:					Any,		__A							:					Union[str, Any],		__A							:					Dict						):
     UpperCAmelCase	:							Optional[Any]						=			self.num_labels
     UpperCAmelCase	:							Union[str, Any]						=			BitForImageClassification(__A						)
     model.to(__A						)
     model.eval()
     UpperCAmelCase	:							Optional[int]						=			model(__A,		labels=__A						)
     self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.num_labels)						)



   def 	__magic_name__   (							self							:					Optional[int],		__A							:					Any,		__A							:					List[str],		__A							:					str						):
     UpperCAmelCase	:							Any						=			BitBackbone(config=__A						)
     model.to(__A						)
     model.eval()
     UpperCAmelCase	:							Tuple						=			model(__A						)

     # verify feature maps
     self.parent.assertEqual(len(result.feature_maps						),		len(config.out_features						)						)
     self.parent.assertListEqual(list(result.feature_maps[0].shape						),		[self.batch_size, self.hidden_sizes[1], 4, 4]						)

     # verify channels
     self.parent.assertEqual(len(model.channels						),		len(config.out_features						)						)
     self.parent.assertListEqual(model.channels,		config.hidden_sizes[1:]						)

     # verify backbone works with out_features=None
     UpperCAmelCase	:							List[str]						=			None
     UpperCAmelCase	:							Optional[Any]						=			BitBackbone(config=__A						)
     model.to(__A						)
     model.eval()
     UpperCAmelCase	:							Tuple						=			model(__A						)

     # verify feature maps
     self.parent.assertEqual(len(result.feature_maps						),		1						)
     self.parent.assertListEqual(list(result.feature_maps[0].shape						),		[self.batch_size, self.hidden_sizes[-1], 1, 1]						)

     # verify channels
     self.parent.assertEqual(len(model.channels						),		1						)
     self.parent.assertListEqual(model.channels,		[config.hidden_sizes[-1]]						)





   def 	__magic_name__   (							self							:					Optional[int]						):
     UpperCAmelCase	:							str						=			self.prepare_config_and_inputs()
     UpperCAmelCase			,						UpperCAmelCase			,						UpperCAmelCase	:							Union[str, Any]						=			config_and_inputs
     UpperCAmelCase	:							Union[str, Any]						=			{'''pixel_values''': pixel_values}
     return config, inputs_dict






@require_torch
class  __UpperCAmelCase					(	lowerCamelCase__      ,  lowerCamelCase__      ,  unittest.TestCase						):
   UpperCamelCase       					=					(BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
   UpperCamelCase       					=					(
       {"""feature-extraction""": BitModel, """image-classification""": BitForImageClassification}
       if is_torch_available()
       else {}
   )

   UpperCamelCase       					=					False
   UpperCamelCase       					=					False
   UpperCamelCase       					=					False
   UpperCamelCase       					=					False
   UpperCamelCase       					=					False



   def 	__magic_name__   (							self							:					Union[str, Any]						):
     UpperCAmelCase	:							Optional[int]						=			BitModelTester(self						)
     UpperCAmelCase	:							Any						=			ConfigTester(self,		config_class=__A,		has_text_modality=__A						)



   def 	__magic_name__   (							self							:					List[str]						):
     self.create_and_test_config_common_properties()
     self.config_tester.create_and_test_config_to_json_string()
     self.config_tester.create_and_test_config_to_json_file()
     self.config_tester.create_and_test_config_from_and_save_pretrained()
     self.config_tester.create_and_test_config_with_num_labels()
     self.config_tester.check_config_can_be_init_without_params()
     self.config_tester.check_config_arguments_init()



   def 	__magic_name__   (							self							:					Union[str, Any]						):
     return



   @unittest.skip(reason='''Bit does not output attentions'''						)
   def 	__magic_name__   (							self							:					List[Any]						):
     pass



   @unittest.skip(reason='''Bit does not use inputs_embeds'''						)
   def 	__magic_name__   (							self							:					Dict						):
     pass



   @unittest.skip(reason='''Bit does not support input and output embeddings'''						)
   def 	__magic_name__   (							self							:					List[Any]						):
     pass



   def 	__magic_name__   (							self							:					List[Any]						):
     UpperCAmelCase			,						UpperCAmelCase	:							Any						=			self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
       UpperCAmelCase	:							Optional[Any]						=			model_class(__A						)
       UpperCAmelCase	:							List[str]						=			inspect.signature(model.forward						)
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       UpperCAmelCase	:							List[str]						=			[*signature.parameters.keys()]

       UpperCAmelCase	:							List[Any]						=			['''pixel_values''']
       self.assertListEqual(arg_names[:1],		__A						)



   def 	__magic_name__   (							self							:					Union[str, Any]						):
     UpperCAmelCase	:							Optional[int]						=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*__A						)



   def 	__magic_name__   (							self							:					int						):
     UpperCAmelCase	:							List[str]						=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*__A						)



   def 	__magic_name__   (							self							:					int						):
     UpperCAmelCase			,						UpperCAmelCase	:							Optional[int]						=			self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
       UpperCAmelCase	:							Dict						=			model_class(config=__A						)
       for name, module in model.named_modules():
         if isinstance(__A,		(nn.BatchNormad, nn.GroupNorm)						):
           self.assertTrue(
               torch.all(module.weight == 1						),		msg=F'''Parameter {name} of model {model_class} seems not properly initialized''',		)
           self.assertTrue(
               torch.all(module.bias == 0						),		msg=F'''Parameter {name} of model {model_class} seems not properly initialized''',		)



   def 	__magic_name__   (							self							:					Dict						):
     def check_hidden_states_output(__A							:					List[Any],		__A							:					Optional[int],		__A							:					int						):
       UpperCAmelCase	:							int						=			model_class(__A						)
       model.to(__A						)
       model.eval()

       with torch.no_grad():
         UpperCAmelCase	:							Any						=			model(**self._prepare_for_class(__A,		__A						)						)

       UpperCAmelCase	:							Union[str, Any]						=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

       UpperCAmelCase	:							Any						=			self.model_tester.num_stages
       self.assertEqual(len(__A						),		expected_num_stages + 1						)

       # Bit's feature maps are of shape (batch_size, num_channels, height, width)
       self.assertListEqual(
           list(hidden_states[0].shape[-2:]						),		[self.model_tester.image_size // 4, self.model_tester.image_size // 4],		)

     UpperCAmelCase			,						UpperCAmelCase	:							Dict						=			self.model_tester.prepare_config_and_inputs_for_common()
     UpperCAmelCase	:							Union[str, Any]						=			['''preactivation''', '''bottleneck''']
     for model_class in self.all_model_classes:
       for layer_type in layers_type:
         UpperCAmelCase	:							int						=			layer_type
         UpperCAmelCase	:							List[Any]						=			True
         check_hidden_states_output(__A,		__A,		__A						)

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         UpperCAmelCase	:							Dict						=			True

         check_hidden_states_output(__A,		__A,		__A						)



   @unittest.skip(reason='''Bit does not use feedforward chunking'''						)
   def 	__magic_name__   (							self							:					List[str]						):
     pass



   def 	__magic_name__   (							self							:					Optional[int]						):
     UpperCAmelCase	:							str						=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*__A						)





   @slow
   def 	__magic_name__   (							self							:					List[Any]						):
     for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCAmelCase	:							List[str]						=			BitModel.from_pretrained(__A						)
       self.assertIsNotNone(__A						)






def       a__					(		)  ->						Union[str, Any]:
  UpperCAmelCase	:							Optional[int]						=			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
  return image





@require_torch
@require_vision
class  __UpperCAmelCase					(	unittest.TestCase						):



   @cached_property
   def 	__magic_name__   (							self							:					Union[str, Any]						):
     return (
         BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						) if is_vision_available() else None
     )





   @slow
   def 	__magic_name__   (							self							:					str						):
     UpperCAmelCase	:							List[Any]						=			BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(__A						)

     UpperCAmelCase	:							str						=			self.default_image_processor
     UpperCAmelCase	:							Dict						=			prepare_img()
     UpperCAmelCase	:							Tuple						=			image_processor(images=__A,		return_tensors='''pt'''						).to(__A						)

     # forward pass
     with torch.no_grad():
       UpperCAmelCase	:							List[Any]						=			model(**__A						)

     # verify the logits
     UpperCAmelCase	:							Dict						=			torch.Size((1, 1_0_0_0)						)
     self.assertEqual(outputs.logits.shape,		__A						)

     UpperCAmelCase	:							int						=			torch.tensor([[-0.6_5_2_6, -0.5_2_6_3, -1.4_3_9_8]]						).to(__A						)

     self.assertTrue(torch.allclose(outputs.logits[0, :3],		__A,		atol=1E-4						)						)






@require_torch
class  __UpperCAmelCase					(	lowerCamelCase__      ,  unittest.TestCase						):
   UpperCamelCase       					=					(BitBackbone,) if is_torch_available() else ()
   UpperCamelCase       					=					BitConfig

   UpperCamelCase       					=					False



   def 	__magic_name__   (							self							:					int						):
     UpperCAmelCase	:							int						=			BitModelTester(self						)





