





import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import DeiTConfig, DeiTForImageClassificationWithTeacher, DeiTImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
snake_case_							=			logging.get_logger(__name__)


def 					A__	(       SCREAMING_SNAKE_CASE_     :   Tuple							,       SCREAMING_SNAKE_CASE_     :   Tuple=False		)   ->     str:
		lowerCamelCase   : Any								=[]
		for i in range(config.num_hidden_layers		):
				# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
				rename_keys.append((F"blocks.{i}.norm1.weight", F"deit.encoder.layer.{i}.layernorm_before.weight")		)
				rename_keys.append((F"blocks.{i}.norm1.bias", F"deit.encoder.layer.{i}.layernorm_before.bias")		)
				rename_keys.append((F"blocks.{i}.attn.proj.weight", F"deit.encoder.layer.{i}.attention.output.dense.weight")		)
				rename_keys.append((F"blocks.{i}.attn.proj.bias", F"deit.encoder.layer.{i}.attention.output.dense.bias")		)
				rename_keys.append((F"blocks.{i}.norm2.weight", F"deit.encoder.layer.{i}.layernorm_after.weight")		)
				rename_keys.append((F"blocks.{i}.norm2.bias", F"deit.encoder.layer.{i}.layernorm_after.bias")		)
				rename_keys.append((F"blocks.{i}.mlp.fc1.weight", F"deit.encoder.layer.{i}.intermediate.dense.weight")		)
				rename_keys.append((F"blocks.{i}.mlp.fc1.bias", F"deit.encoder.layer.{i}.intermediate.dense.bias")		)
				rename_keys.append((F"blocks.{i}.mlp.fc2.weight", F"deit.encoder.layer.{i}.output.dense.weight")		)
				rename_keys.append((F"blocks.{i}.mlp.fc2.bias", F"deit.encoder.layer.{i}.output.dense.bias")		)

		# projection layer + position embeddings
		rename_keys.extend(
		    [
		        ('''cls_token''', '''deit.embeddings.cls_token'''),
		        ('''dist_token''', '''deit.embeddings.distillation_token'''),
		        ('''patch_embed.proj.weight''', '''deit.embeddings.patch_embeddings.projection.weight'''),
		        ('''patch_embed.proj.bias''', '''deit.embeddings.patch_embeddings.projection.bias'''),
		        ('''pos_embed''', '''deit.embeddings.position_embeddings'''),
		    ]		)

		if base_model:
				# layernorm + pooler
				rename_keys.extend(
				    [
				        ('''norm.weight''', '''layernorm.weight'''),
				        ('''norm.bias''', '''layernorm.bias'''),
				        ('''pre_logits.fc.weight''', '''pooler.dense.weight'''),
				        ('''pre_logits.fc.bias''', '''pooler.dense.bias'''),
				    ]		)

				# if just the base model, we should remove "deit" from all keys that start with "deit"
				lowerCamelCase   : Optional[int]								=[(pair[0], pair[1][4:]) if pair[1].startswith('''deit'''		) else pair for pair in rename_keys]
		else:
				# layernorm + classification heads
				rename_keys.extend(
				    [
				        ('''norm.weight''', '''deit.layernorm.weight'''),
				        ('''norm.bias''', '''deit.layernorm.bias'''),
				        ('''head.weight''', '''cls_classifier.weight'''),
				        ('''head.bias''', '''cls_classifier.bias'''),
				        ('''head_dist.weight''', '''distillation_classifier.weight'''),
				        ('''head_dist.bias''', '''distillation_classifier.bias'''),
				    ]		)

		return rename_keys


def 					A__	(       SCREAMING_SNAKE_CASE_     :   List[Any]							,       SCREAMING_SNAKE_CASE_     :   List[str]							,       SCREAMING_SNAKE_CASE_     :   Optional[Any]=False		)   ->     Any:


		for i in range(config.num_hidden_layers		):
				if base_model:
						lowerCamelCase   : List[str]								=""
				else:
						lowerCamelCase   : List[Any]								="deit."
				# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
				lowerCamelCase   : Dict								=state_dict.pop(F"blocks.{i}.attn.qkv.weight"		)
				lowerCamelCase   : Dict								=state_dict.pop(F"blocks.{i}.attn.qkv.bias"		)
				# next, add query, keys and values (in that order) to the state dict
				lowerCamelCase   : Any								=in_proj_weight[
				    : config.hidden_size, :
				]
				lowerCamelCase   : List[str]								=in_proj_bias[: config.hidden_size]
				lowerCamelCase   : int								=in_proj_weight[
				    config.hidden_size : config.hidden_size * 2, :
				]
				lowerCamelCase   : List[Any]								=in_proj_bias[
				    config.hidden_size : config.hidden_size * 2
				]
				lowerCamelCase   : Optional[Any]								=in_proj_weight[
				    -config.hidden_size :, :
				]
				lowerCamelCase   : Union[str, Any]								=in_proj_bias[-config.hidden_size :]


def 					A__	(       SCREAMING_SNAKE_CASE_     :   Dict							,       SCREAMING_SNAKE_CASE_     :   int							,       SCREAMING_SNAKE_CASE_     :   Tuple		)   ->     Tuple:
		lowerCamelCase   : Optional[int]								=dct.pop(__snake_case		)
		lowerCamelCase   : Dict								=val


def 					A__	(       )   ->     int:
		lowerCamelCase   : Tuple								="http://images.cocodataset.org/val2017/000000039769.jpg"
		lowerCamelCase   : Optional[int]								=Image.open(requests.get(__snake_case							,       stream=__snake_case		).raw		)
		return im


@torch.no_grad()
def 					A__	(       SCREAMING_SNAKE_CASE_     :   Tuple							,       SCREAMING_SNAKE_CASE_     :   List[Any]		)   ->     Any:
		lowerCamelCase   : Optional[Any]								=DeiTConfig()
		# all deit models have fine-tuned heads
		lowerCamelCase   : Tuple								=False
		# dataset (fine-tuned on ImageNet 2012), patch_size and image_size
		lowerCamelCase   : Optional[int]								=1_0_0_0
		lowerCamelCase   : Tuple								="huggingface/label-files"
		lowerCamelCase   : Union[str, Any]								="imagenet-1k-id2label.json"
		lowerCamelCase   : Dict								=json.load(open(hf_hub_download(__snake_case							,       __snake_case							,       repo_type='''dataset'''		)							,       '''r'''		)		)
		lowerCamelCase   : int								={int(__snake_case		): v for k, v in idalabel.items()}
		lowerCamelCase   : List[str]								=idalabel
		lowerCamelCase   : Union[str, Any]								={v: k for k, v in idalabel.items()}
		lowerCamelCase   : int								=int(deit_name[-6:-4]		)
		lowerCamelCase   : str								=int(deit_name[-3:]		)
		# size of the architecture
		if deit_name[9:].startswith('''tiny'''		):
				lowerCamelCase   : Union[str, Any]								=1_9_2
				lowerCamelCase   : Optional[Any]								=7_6_8
				lowerCamelCase   : Tuple								=1_2
				lowerCamelCase   : int								=3
		elif deit_name[9:].startswith('''small'''		):
				lowerCamelCase   : Any								=3_8_4
				lowerCamelCase   : Union[str, Any]								=1_5_3_6
				lowerCamelCase   : List[Any]								=1_2
				lowerCamelCase   : Optional[Any]								=6
		if deit_name[9:].startswith('''base'''		):
				pass
		elif deit_name[4:].startswith('''large'''		):
				lowerCamelCase   : Tuple								=1_0_2_4
				lowerCamelCase   : int								=4_0_9_6
				lowerCamelCase   : List[Any]								=2_4
				lowerCamelCase   : Any								=1_6

		# load original model from timm
		lowerCamelCase   : Optional[Any]								=timm.create_model(__snake_case							,       pretrained=__snake_case		)
		timm_model.eval()

		# load state_dict of original model, remove and rename some keys
		lowerCamelCase   : str								=timm_model.state_dict()
		lowerCamelCase   : Any								=create_rename_keys(__snake_case							,       __snake_case		)
		for src, dest in rename_keys:
				rename_key(__snake_case							,       __snake_case							,       __snake_case		)
		read_in_q_k_v(__snake_case							,       __snake_case							,       __snake_case		)

		# load HuggingFace model
		lowerCamelCase   : List[Any]								=DeiTForImageClassificationWithTeacher(__snake_case		).eval()
		model.load_state_dict(__snake_case		)

		# Check outputs on an image, prepared by DeiTImageProcessor
		lowerCamelCase   : List[str]								=int(
		    (2_5_6 / 2_2_4) * config.image_size		)  # to maintain same ratio w.r.t. 224 images, see https://github.com/facebookresearch/deit/blob/ab5715372db8c6cad5740714b2216d55aeae052e/datasets.py#L103
		lowerCamelCase   : str								=DeiTImageProcessor(size=__snake_case							,       crop_size=config.image_size		)
		lowerCamelCase   : List[Any]								=image_processor(images=prepare_img()							,       return_tensors='''pt'''		)
		lowerCamelCase   : str								=encoding["pixel_values"]
		lowerCamelCase   : List[str]								=model(__snake_case		)

		lowerCamelCase   : Optional[Any]								=timm_model(__snake_case		)
		assert timm_logits.shape == outputs.logits.shape
		assert torch.allclose(__snake_case							,       outputs.logits							,       atol=1E-3		)

		Path(__snake_case		).mkdir(exist_ok=__snake_case		)
		print(F"Saving model {deit_name} to {pytorch_dump_folder_path}"		)
		model.save_pretrained(__snake_case		)
		print(F"Saving image processor to {pytorch_dump_folder_path}"		)
		image_processor.save_pretrained(__snake_case		)


if __name__ == "__main__":
				snake_case_							=			argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '''--deit_name''',
				    default='''vit_deit_base_distilled_patch16_224''',
				    type=str,
				    help='''Name of the DeiT timm model you\'d like to convert.''',
				)
				parser.add_argument(
				    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
				)

				snake_case_							=			parser.parse_args()
				convert_deit_checkpoint(args.deit_name, args.pytorch_dump_folder_path)








import json
import os
from pathlib import Path
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple, Union

import sentencepiece

from ...tokenization_utils import BatchEncoding, PreTrainedTokenizer
from ...utils import logging


snake_case_							=			logging.get_logger(__name__)

snake_case_							=			'''▁'''

snake_case_							=			{
    '''vocab_file''': '''vocab.json''',
    '''spm_file''': '''sentencepiece.bpe.model''',
    '''tokenizer_config_file''': '''tokenizer_config.json''',
}

snake_case_							=			{
    '''vocab_file''': {
        '''facebook/m2m100_418M''': '''https://huggingface.co/facebook/m2m100_418M/resolve/main/vocab.json''',
        '''facebook/m2m100_1.2B''': '''https://huggingface.co/facebook/m2m100_1.2B/resolve/main/vocab.json''',
    },
    '''spm_file''': {
        '''facebook/m2m100_418M''': '''https://huggingface.co/facebook/m2m100_418M/resolve/main/sentencepiece.bpe.model''',
        '''facebook/m2m100_1.2B''': '''https://huggingface.co/facebook/m2m100_1.2B/resolve/main/sentencepiece.bpe.model''',
    },
    '''tokenizer_config_file''': {
        '''facebook/m2m100_418M''': '''https://huggingface.co/facebook/m2m100_418M/resolve/main/tokenizer_config.json''',
        '''facebook/m2m100_1.2B''': '''https://huggingface.co/facebook/m2m100_1.2B/resolve/main/tokenizer_config.json''',
    },
}

snake_case_							=			{
    '''facebook/m2m100_418M''': 1_0_2_4,
}

# fmt: off
snake_case_							=			{
    '''m2m100''': ['''af''', '''am''', '''ar''', '''ast''', '''az''', '''ba''', '''be''', '''bg''', '''bn''', '''br''', '''bs''', '''ca''', '''ceb''', '''cs''', '''cy''', '''da''', '''de''', '''el''', '''en''', '''es''', '''et''', '''fa''', '''ff''', '''fi''', '''fr''', '''fy''', '''ga''', '''gd''', '''gl''', '''gu''', '''ha''', '''he''', '''hi''', '''hr''', '''ht''', '''hu''', '''hy''', '''id''', '''ig''', '''ilo''', '''is''', '''it''', '''ja''', '''jv''', '''ka''', '''kk''', '''km''', '''kn''', '''ko''', '''lb''', '''lg''', '''ln''', '''lo''', '''lt''', '''lv''', '''mg''', '''mk''', '''ml''', '''mn''', '''mr''', '''ms''', '''my''', '''ne''', '''nl''', '''no''', '''ns''', '''oc''', '''or''', '''pa''', '''pl''', '''ps''', '''pt''', '''ro''', '''ru''', '''sd''', '''si''', '''sk''', '''sl''', '''so''', '''sq''', '''sr''', '''ss''', '''su''', '''sv''', '''sw''', '''ta''', '''th''', '''tl''', '''tn''', '''tr''', '''uk''', '''ur''', '''uz''', '''vi''', '''wo''', '''xh''', '''yi''', '''yo''', '''zh''', '''zu'''],
    '''wmt21''': ['''en''', '''ha''', '''is''', '''ja''', '''cs''', '''ru''', '''zh''', '''de''']
}
class        snake_case_		(			_A):
		lowerCamelCase    :Union[str, Any]						=     VOCAB_FILES_NAMES
		lowerCamelCase    :List[Any]						=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowerCamelCase    :str						=     PRETRAINED_VOCAB_FILES_MAP
		lowerCamelCase    :Union[str, Any]						=     ["input_ids", "attention_mask"]

		lowerCamelCase    :List[int]						=     []
		lowerCamelCase    :List[int]						=     []







		def __init__(		self			,     __lowercase			,     __lowercase			,     __lowercase=None			,     __lowercase=None			,     __lowercase="<s>"			,     __lowercase="</s>"			,     __lowercase="</s>"			,     __lowercase="<pad>"			,     __lowercase="<unk>"			,     __lowercase="m2m100"			,     __lowercase = None			,     __lowercase=8			,     **__lowercase			,     )				->   None:
				lowerCamelCase   : Union[str, Any]								={} if sp_model_kwargs is None else sp_model_kwargs

				lowerCamelCase   : List[str]								=language_codes
				lowerCamelCase   : int								=FAIRSEQ_LANGUAGE_CODES[language_codes]
				lowerCamelCase   : str								={lang_code: F"__{lang_code}__" for lang_code in fairseq_language_code}

				lowerCamelCase   : List[Any]								=kwargs.get('''additional_special_tokens'''			,     []   )
				kwargs["additional_special_tokens"] += [
				    self.get_lang_token(__lowercase   )
				    for lang_code in fairseq_language_code
				    if self.get_lang_token(__lowercase   ) not in kwargs["additional_special_tokens"]
				]

				super().__init__(
				    src_lang=__lowercase			,     tgt_lang=__lowercase			,     bos_token=__lowercase			,     eos_token=__lowercase			,     sep_token=__lowercase			,     unk_token=__lowercase			,     pad_token=__lowercase			,     language_codes=__lowercase			,     sp_model_kwargs=self.sp_model_kwargs			,     num_madeup_words=__lowercase			,     **__lowercase			,     )

				lowerCamelCase   : Dict								=vocab_file
				lowerCamelCase   : List[Any]								=load_json(__lowercase   )
				lowerCamelCase   : Optional[int]								={v: k for k, v in self.encoder.items()}
				lowerCamelCase   : List[Any]								=spm_file
				lowerCamelCase   : str								=load_spm(__lowercase			,     self.sp_model_kwargs   )

				lowerCamelCase   : Tuple								=len(self.encoder   )

				lowerCamelCase   : Optional[int]								={
				    self.get_lang_token(__lowercase   ): self.encoder_size + i for i, lang_code in enumerate(__lowercase   )
				}
				lowerCamelCase   : Tuple								={lang_code: self.encoder_size + i for i, lang_code in enumerate(__lowercase   )}
				lowerCamelCase   : Tuple								={v: k for k, v in self.lang_token_to_id.items()}

				lowerCamelCase   : Optional[Any]								=src_lang if src_lang is not None else '''en'''
				lowerCamelCase   : Any								=tgt_lang
				lowerCamelCase   : List[Any]								=self.get_lang_id(self._src_lang   )
				self.set_src_lang_special_tokens(self._src_lang   )

				lowerCamelCase   : Optional[Any]								=num_madeup_words







		@property
		def 			__lowercase   (		self   )				->   int:
				return len(self.encoder   ) + len(self.lang_token_to_id   )







		@property
		def 			__lowercase   (		self   )				->   str:
				return self._src_lang







		@src_lang.setter
		def 			__lowercase   (		self			,     __lowercase   )				->   None:
				lowerCamelCase   : Any								=new_src_lang
				self.set_src_lang_special_tokens(self._src_lang   )







		def 			__lowercase   (		self			,     __lowercase   )				->   List[str]:
				return self.sp_model.encode(__lowercase			,     out_type=__lowercase   )







		def 			__lowercase   (		self			,     __lowercase   )				->   Optional[Any]:
				if token in self.lang_token_to_id:
						return self.lang_token_to_id[token]
				return self.encoder.get(__lowercase			,     self.encoder[self.unk_token]   )







		def 			__lowercase   (		self			,     __lowercase   )				->   str:
				if index in self.id_to_lang_token:
						return self.id_to_lang_token[index]
				return self.decoder.get(__lowercase			,     self.unk_token   )







		def 			__lowercase   (		self			,     __lowercase   )				->   str:
				lowerCamelCase   : Dict								=[]
				lowerCamelCase   : Dict								=''''''
				for token in tokens:
						# make sure that special tokens are not decoded using sentencepiece model
						if token in self.all_special_tokens:
								out_string += self.sp_model.decode(__lowercase   ) + token
								lowerCamelCase   : str								=[]
						else:
								current_sub_tokens.append(__lowercase   )
				out_string += self.sp_model.decode(__lowercase   )
				return out_string.strip()







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase = None			,     __lowercase = False   )				->   List[int]:

				if already_has_special_tokens:
						return super().get_special_tokens_mask(
						    token_ids_a=__lowercase			,     token_ids_a=__lowercase			,     already_has_special_tokens=__lowercase   )

				lowerCamelCase   : int								=[1] * len(self.prefix_tokens   )
				lowerCamelCase   : List[str]								=[1] * len(self.suffix_tokens   )
				if token_ids_a is None:
						return prefix_ones + ([0] * len(__lowercase   )) + suffix_ones
				return prefix_ones + ([0] * len(__lowercase   )) + ([0] * len(__lowercase   )) + suffix_ones







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase = None   )				->   List[int]:
				if token_ids_a is None:
						return self.prefix_tokens + token_ids_a + self.suffix_tokens
				# We don't expect to process pairs, but leave the pair logic for API consistency
				return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens







		def 			__lowercase   (		self   )				->   Dict:
				lowerCamelCase   : Dict								={self.convert_ids_to_tokens(__lowercase   ): i for i in range(self.vocab_size   )}
				vocab.update(self.added_tokens_encoder   )
				return vocab







		def __getstate__(		self   )				->   Dict:
				lowerCamelCase   : Optional[Any]								=self.__dict__.copy()
				lowerCamelCase   : Union[str, Any]								=None
				return state







		def __setstate__(		self			,     __lowercase   )				->   None:
				lowerCamelCase   : int								=d

				# for backward compatibility
				if not hasattr(self			,     '''sp_model_kwargs'''   ):
						lowerCamelCase   : Optional[int]								={}

				lowerCamelCase   : Optional[Any]								=load_spm(self.spm_file			,     self.sp_model_kwargs   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase = None   )				->   Tuple[str]:
				lowerCamelCase   : Optional[Any]								=Path(__lowercase   )
				if not save_dir.is_dir():
						raise OSError(F"{save_directory} should be a directory"   )
				lowerCamelCase   : List[str]								=save_dir / (
				    (filename_prefix + '''-''' if filename_prefix else '''''') + self.vocab_files_names['''vocab_file''']
				)
				lowerCamelCase   : Tuple								=save_dir / (
				    (filename_prefix + '''-''' if filename_prefix else '''''') + self.vocab_files_names['''spm_file''']
				)

				save_json(self.encoder			,     __lowercase   )

				if os.path.abspath(self.spm_file   ) != os.path.abspath(__lowercase   ) and os.path.isfile(self.spm_file   ):
						copyfile(self.spm_file			,     __lowercase   )
				elif not os.path.isfile(self.spm_file   ):
						with open(__lowercase			,     '''wb'''   ) as fi:
								lowerCamelCase   : List[Any]								=self.sp_model.serialized_model_proto()
								fi.write(__lowercase   )

				return (str(__lowercase   ), str(__lowercase   ))







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase = "en"			,     __lowercase = None			,     __lowercase = "ro"			,     **__lowercase			,     )				->   BatchEncoding:
				lowerCamelCase   : Union[str, Any]								=src_lang
				lowerCamelCase   : Optional[int]								=tgt_lang
				self.set_src_lang_special_tokens(self.src_lang   )
				return super().prepare_seqaseq_batch(__lowercase			,     __lowercase			,     **__lowercase   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     **__lowercase   )				->   Optional[int]:
				if src_lang is None or tgt_lang is None:
						raise ValueError('''Translation requires a `src_lang` and a `tgt_lang` for this model'''   )
				lowerCamelCase   : List[Any]								=src_lang
				lowerCamelCase   : str								=self(__lowercase			,     add_special_tokens=__lowercase			,     **__lowercase   )
				lowerCamelCase   : Tuple								=self.get_lang_id(__lowercase   )
				lowerCamelCase   : Optional[int]								=tgt_lang_id
				return inputs







		def 			__lowercase   (		self   )				->   List[str]:
				self.set_src_lang_special_tokens(self.src_lang   )







		def 			__lowercase   (		self   )				->   List[str]:
				self.set_tgt_lang_special_tokens(self.tgt_lang   )







		def 			__lowercase   (		self			,     __lowercase   )				->   None:
				lowerCamelCase   : Union[str, Any]								=self.get_lang_token(__lowercase   )
				lowerCamelCase   : List[Any]								=self.lang_token_to_id[lang_token]
				lowerCamelCase   : Optional[Any]								=[self.cur_lang_id]
				lowerCamelCase   : Union[str, Any]								=[self.eos_token_id]







		def 			__lowercase   (		self			,     __lowercase   )				->   None:
				lowerCamelCase   : Tuple								=self.get_lang_token(__lowercase   )
				lowerCamelCase   : Tuple								=self.lang_token_to_id[lang_token]
				lowerCamelCase   : List[Any]								=[self.cur_lang_id]
				lowerCamelCase   : Tuple								=[self.eos_token_id]







		def 			__lowercase   (		self			,     __lowercase   )				->   str:
				return self.lang_code_to_token[lang]







		def 			__lowercase   (		self			,     __lowercase   )				->   int:
				lowerCamelCase   : List[str]								=self.get_lang_token(__lowercase   )
				return self.lang_token_to_id[lang_token]


def 					A__	(       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_		)   ->     sentencepiece.SentencePieceProcessor:
		lowerCamelCase   : List[Any]								=sentencepiece.SentencePieceProcessor(**SCREAMING_SNAKE_CASE_		)
		spm.Load(str(SCREAMING_SNAKE_CASE_		)		)
		return spm


def 					A__	(       SCREAMING_SNAKE_CASE_		)   ->     Union[Dict, List]:
		with open(SCREAMING_SNAKE_CASE_							,       '''r'''		) as f:
				return json.load(SCREAMING_SNAKE_CASE_		)



def 					A__	(       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_		)   ->     None:
		with open(SCREAMING_SNAKE_CASE_							,       '''w'''		) as f:
				json.dump(SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       indent=2		)

