






"""simple docstring"""



import json
import os
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

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


if TYPE_CHECKING:
						from transformers.pipelines.conversational import Conversation

_snake_case       :      Union[str, Any]       =					logging.get_logger(__name__)

_snake_case       :      Optional[Any]       =					{"vocab_file": "vocab.json", "merges_file": "merges.txt"}

_snake_case       :      Any       =					{
    "vocab_file": {
        "microsoft/deberta-base": "https://huggingface.co/microsoft/deberta-base/resolve/main/vocab.json",
        "microsoft/deberta-large": "https://huggingface.co/microsoft/deberta-large/resolve/main/vocab.json",
        "microsoft/deberta-xlarge": "https://huggingface.co/microsoft/deberta-xlarge/resolve/main/vocab.json",
        "microsoft/deberta-base-mnli": "https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/vocab.json",
        "microsoft/deberta-large-mnli": "https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/vocab.json",
        "microsoft/deberta-xlarge-mnli": (
            "https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/vocab.json"
        ),
    },
    "merges_file": {
        "microsoft/deberta-base": "https://huggingface.co/microsoft/deberta-base/resolve/main/merges.txt",
        "microsoft/deberta-large": "https://huggingface.co/microsoft/deberta-large/resolve/main/merges.txt",
        "microsoft/deberta-xlarge": "https://huggingface.co/microsoft/deberta-xlarge/resolve/main/merges.txt",
        "microsoft/deberta-base-mnli": "https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/merges.txt",
        "microsoft/deberta-large-mnli": "https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/merges.txt",
        "microsoft/deberta-xlarge-mnli": (
            "https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/merges.txt"
        ),
    },
}

_snake_case       :      Union[str, Any]       =					{
    "microsoft/deberta-base": 512,
    "microsoft/deberta-large": 512,
    "microsoft/deberta-xlarge": 512,
    "microsoft/deberta-base-mnli": 512,
    "microsoft/deberta-large-mnli": 512,
    "microsoft/deberta-xlarge-mnli": 512,
}

_snake_case       :      str       =					{
    "microsoft/deberta-base": {"do_lower_case": False},
    "microsoft/deberta-large": {"do_lower_case": False},
}




def 						lowerCamelCase_				(  ):
					lowerCamelCase__				=(
					    list(range(ord('!'			)			,	ord('~'			) + 1			)			) + list(range(ord('¡'			)			,	ord('¬'			) + 1			)			) + list(range(ord('®'			)			,	ord('ÿ'			) + 1			)			)
					)
					lowerCamelCase__				=bs[:]
					lowerCamelCase__				=0
					for b in range(2**8			):
										if b not in bs:
															bs.append(__A			)
															cs.append(2**8 + n			)
															n += 1
					lowerCamelCase__				=[chr(__A			) for n in cs]
					return dict(zip(__A			,	__A			)			)




def 						lowerCamelCase_				(  __A  :		Tuple			):
					lowerCamelCase__				=set()
					lowerCamelCase__				=word[0]
					for char in word[1:]:
										pairs.add((prev_char, char)			)
										lowerCamelCase__				=char
					return pairs




class        __lowercase(       _UpperCamelCase  ):
						lowerCAmelCase_		:							str=       VOCAB_FILES_NAMES
						lowerCAmelCase_		:							Tuple=       PRETRAINED_VOCAB_FILES_MAP
						lowerCAmelCase_		:							int=       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						lowerCAmelCase_		:							List[Any]=       ["""input_ids""", """attention_mask""", """token_type_ids"""]






						def __init__(					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE="replace"    ,						_SCREAMING_SNAKE_CASE="[CLS]"    ,						_SCREAMING_SNAKE_CASE="[SEP]"    ,						_SCREAMING_SNAKE_CASE="[SEP]"    ,						_SCREAMING_SNAKE_CASE="[CLS]"    ,						_SCREAMING_SNAKE_CASE="[UNK]"    ,						_SCREAMING_SNAKE_CASE="[PAD]"    ,						_SCREAMING_SNAKE_CASE="[MASK]"    ,						_SCREAMING_SNAKE_CASE=False    ,						_SCREAMING_SNAKE_CASE=False    ,						**_SCREAMING_SNAKE_CASE    ,						)			->  Dict:




											"""simple docstring"""





											lowerCamelCase__				=AddedToken(_SCREAMING_SNAKE_CASE    ,						lstrip=_SCREAMING_SNAKE_CASE    ,						rstrip=_SCREAMING_SNAKE_CASE) if isinstance(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE) else bos_token
											lowerCamelCase__				=AddedToken(_SCREAMING_SNAKE_CASE    ,						lstrip=_SCREAMING_SNAKE_CASE    ,						rstrip=_SCREAMING_SNAKE_CASE) if isinstance(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE) else eos_token
											lowerCamelCase__				=AddedToken(_SCREAMING_SNAKE_CASE    ,						lstrip=_SCREAMING_SNAKE_CASE    ,						rstrip=_SCREAMING_SNAKE_CASE) if isinstance(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE) else sep_token
											lowerCamelCase__				=AddedToken(_SCREAMING_SNAKE_CASE    ,						lstrip=_SCREAMING_SNAKE_CASE    ,						rstrip=_SCREAMING_SNAKE_CASE) if isinstance(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE) else cls_token
											lowerCamelCase__				=AddedToken(_SCREAMING_SNAKE_CASE    ,						lstrip=_SCREAMING_SNAKE_CASE    ,						rstrip=_SCREAMING_SNAKE_CASE) if isinstance(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE) else unk_token
											lowerCamelCase__				=AddedToken(_SCREAMING_SNAKE_CASE    ,						lstrip=_SCREAMING_SNAKE_CASE    ,						rstrip=_SCREAMING_SNAKE_CASE) if isinstance(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE) else pad_token

											# Mask token behave like a normal word, i.e. include the space before it
											lowerCamelCase__				=AddedToken(_SCREAMING_SNAKE_CASE    ,						lstrip=_SCREAMING_SNAKE_CASE    ,						rstrip=_SCREAMING_SNAKE_CASE) if isinstance(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE) else mask_token

											super().__init__(
											    errors=_SCREAMING_SNAKE_CASE    ,						bos_token=_SCREAMING_SNAKE_CASE    ,						eos_token=_SCREAMING_SNAKE_CASE    ,						unk_token=_SCREAMING_SNAKE_CASE    ,						sep_token=_SCREAMING_SNAKE_CASE    ,						cls_token=_SCREAMING_SNAKE_CASE    ,						pad_token=_SCREAMING_SNAKE_CASE    ,						mask_token=_SCREAMING_SNAKE_CASE    ,						add_prefix_space=_SCREAMING_SNAKE_CASE    ,						add_bos_token=_SCREAMING_SNAKE_CASE    ,						**_SCREAMING_SNAKE_CASE    ,						)
											lowerCamelCase__				=add_bos_token

											with open(_SCREAMING_SNAKE_CASE    ,						encoding='utf-8') as vocab_handle:
																lowerCamelCase__				=json.load(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				={v: k for k, v in self.encoder.items()}
											lowerCamelCase__				=errors  # how to handle errors in decoding
											lowerCamelCase__				=bytes_to_unicode()
											lowerCamelCase__				={v: k for k, v in self.byte_encoder.items()}
											with open(_SCREAMING_SNAKE_CASE    ,						encoding='utf-8') as merges_handle:
																lowerCamelCase__				=merges_handle.read().split('\n')[1:-1]
											lowerCamelCase__				=[tuple(merge.split()) for merge in bpe_merges]
											lowerCamelCase__				=dict(zip(_SCREAMING_SNAKE_CASE    ,						range(len(_SCREAMING_SNAKE_CASE))))
											lowerCamelCase__				={}
											lowerCamelCase__				=add_prefix_space

											# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
											lowerCamelCase__				=re.compile(r'\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+')






						@property
						# Copied from transformers.models.gpt2.tokenization_gpt2.GPT2Tokenizer.vocab_size
						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											return len(self.encoder)






						def 		lowerCAmelCase   (					self)			->  str:




											"""simple docstring"""





											return dict(self.encoder    ,						**self.added_tokens_encoder)






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  str:




											"""simple docstring"""





											if token in self.cache:
																return self.cache[token]
											lowerCamelCase__				=tuple(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=get_pairs(_SCREAMING_SNAKE_CASE)

											if not pairs:
																return token

											while True:
																lowerCamelCase__				=min(_SCREAMING_SNAKE_CASE    ,						key=lambda _SCREAMING_SNAKE_CASE: self.bpe_ranks.get(_SCREAMING_SNAKE_CASE    ,						float('inf')))
																if bigram not in self.bpe_ranks:
																					break
																lowerCamelCase__				,     lowerCamelCase__				=bigram
																lowerCamelCase__				=[]
																lowerCamelCase__				=0
																while i < len(_SCREAMING_SNAKE_CASE):
																					try:
																										lowerCamelCase__				=word.index(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)
																					except ValueError:
																										new_word.extend(word[i:])
																										break
																					else:
																										new_word.extend(word[i:j])
																										lowerCamelCase__				=j

																					if word[i] == first and i < len(_SCREAMING_SNAKE_CASE) - 1 and word[i + 1] == second:
																										new_word.append(first + second)
																										i += 2
																					else:
																										new_word.append(word[i])
																										i += 1
																lowerCamelCase__				=tuple(_SCREAMING_SNAKE_CASE)
																lowerCamelCase__				=new_word
																if len(_SCREAMING_SNAKE_CASE) == 1:
																					break
																else:
																					lowerCamelCase__				=get_pairs(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=' '.join(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=word
											return word






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE = None)			->  List[int]:




											"""simple docstring"""





											if token_ids_a is None:
																return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
											lowerCamelCase__				=[self.cls_token_id]
											lowerCamelCase__				=[self.sep_token_id]
											return cls + token_ids_a + sep + token_ids_a + sep






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




											"""simple docstring"""





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

											if token_ids_a is None:
																return [1] + ([0] * len(_SCREAMING_SNAKE_CASE)) + [1]
											return [1] + ([0] * len(_SCREAMING_SNAKE_CASE)) + [1] + ([0] * len(_SCREAMING_SNAKE_CASE)) + [1]






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE = None)			->  List[int]:




											"""simple docstring"""





											lowerCamelCase__				=[self.sep_token_id]
											lowerCamelCase__				=[self.cls_token_id]

											if token_ids_a is None:
																return len(cls + token_ids_a + sep) * [0]
											return len(cls + token_ids_a + sep) * [0] + len(token_ids_a + sep) * [1]






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  Dict:




											"""simple docstring"""





											lowerCamelCase__				=[]
											for token in re.findall(self.pat    ,						_SCREAMING_SNAKE_CASE):
																lowerCamelCase__				=''.join(
																    self.byte_encoder[b] for b in token.encode('utf-8'))  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
																bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_SCREAMING_SNAKE_CASE).split(' '))
											return bpe_tokens






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  Optional[int]:




											"""simple docstring"""





											return self.encoder.get(_SCREAMING_SNAKE_CASE    ,						self.encoder.get(self.unk_token))






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  Union[str, Any]:




											"""simple docstring"""





											return self.decoder.get(_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  Tuple:




											"""simple docstring"""





											lowerCamelCase__				=''.join(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=bytearray([self.byte_decoder[c] for c in text]).decode('utf-8'    ,						errors=self.errors)
											return text






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE = None)			->  Tuple[str]:




											"""simple docstring"""





											if not os.path.isdir(_SCREAMING_SNAKE_CASE):
																logger.error(F"Vocabulary path ({save_directory}) should be a directory")
																return
											lowerCamelCase__				=os.path.join(
											    _SCREAMING_SNAKE_CASE    ,						(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'])
											lowerCamelCase__				=os.path.join(
											    _SCREAMING_SNAKE_CASE    ,						(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file'])

											with open(_SCREAMING_SNAKE_CASE    ,						'w'    ,						encoding='utf-8') as f:
																f.write(json.dumps(self.encoder    ,						indent=2    ,						sort_keys=_SCREAMING_SNAKE_CASE    ,						ensure_ascii=_SCREAMING_SNAKE_CASE) + '\n')

											lowerCamelCase__				=0
											with open(_SCREAMING_SNAKE_CASE    ,						'w'    ,						encoding='utf-8') as writer:
																writer.write('#version: 0.2\n')
																for bpe_tokens, token_index in sorted(self.bpe_ranks.items()    ,						key=lambda _SCREAMING_SNAKE_CASE: kv[1]):
																					if index != token_index:
																										logger.warning(
																										    F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
																										    ' Please check that the tokenizer is not corrupted!')
																										lowerCamelCase__				=token_index
																					writer.write(' '.join(_SCREAMING_SNAKE_CASE) + '\n')
																					index += 1

											return vocab_file, merge_file






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE=False    ,						**_SCREAMING_SNAKE_CASE)			->  int:




											"""simple docstring"""





											lowerCamelCase__				=kwargs.pop('add_prefix_space'    ,						self.add_prefix_space)
											if (is_split_into_words or add_prefix_space) and (len(_SCREAMING_SNAKE_CASE) > 0 and not text[0].isspace()):
																lowerCamelCase__				=' ' + text
											return (text, kwargs)






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  List[int]:




											"""simple docstring"""





											lowerCamelCase__				=[]
											for is_user, text in conversation.iter_texts():
																input_ids.extend(self.encode(_SCREAMING_SNAKE_CASE    ,						add_special_tokens=_SCREAMING_SNAKE_CASE) + [self.eos_token_id])
											if len(_SCREAMING_SNAKE_CASE) > self.model_max_length:
																lowerCamelCase__				=input_ids[-self.model_max_length :]
											return input_ids







"""simple docstring"""



import datasets

from .evaluate import (
    apply_no_ans_threshold,
    find_all_best_thresh,
    get_raw_scores,
    make_eval_dict,
    make_qid_to_has_ans,
    merge_eval,
)


_snake_case       :      Dict       =					"\\n@inproceedings{Rajpurkar2016SQuAD10,\n  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n  booktitle={EMNLP},\n  year={2016}\n}\n"

_snake_case       :      List[str]       =					"\nThis metric wrap the official scoring script for version 2 of the Stanford Question\nAnswering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n\nSQuAD2.0 combines the 100,000 questions in SQuAD1.1 with over 50,000 unanswerable questions\nwritten adversarially by crowdworkers to look similar to answerable ones.\nTo do well on SQuAD2.0, systems must not only answer questions when possible, but also\ndetermine when no answer is supported by the paragraph and abstain from answering.\n"

_snake_case       :      Dict       =					"\nComputes SQuAD v2 scores (F1 and EM).\nArgs:\n    predictions: List of triple for question-answers to score with the following elements:\n        - the question-answer 'id' field as given in the references (see below)\n        - the text of the answer\n        - the probability that the question has no answer\n    references: List of question-answers dictionaries with the following key-values:\n            - 'id': id of the question-answer pair (see above),\n            - 'answers': a list of Dict {'text': text of the answer as a string}\n    no_answer_threshold: float\n        Probability threshold to decide that a question has no answer.\nReturns:\n    'exact': Exact match (the normalized answer exactly match the gold answer)\n    'f1': The F-score of predicted tokens versus the gold answer\n    'total': Number of score considered\n    'HasAns_exact': Exact match (the normalized answer exactly match the gold answer)\n    'HasAns_f1': The F-score of predicted tokens versus the gold answer\n    'HasAns_total': Number of score considered\n    'NoAns_exact': Exact match (the normalized answer exactly match the gold answer)\n    'NoAns_f1': The F-score of predicted tokens versus the gold answer\n    'NoAns_total': Number of score considered\n    'best_exact': Best exact match (with varying threshold)\n    'best_exact_thresh': No-answer probability threshold associated to the best exact match\n    'best_f1': Best F1 (with varying threshold)\n    'best_f1_thresh': No-answer probability threshold associated to the best F1\nExamples:\n\n    >>> predictions = [{'prediction_text': '1976', 'id': '56e10a3be3433e1400422b22', 'no_answer_probability': 0.}]\n    >>> references = [{'answers': {'answer_start': [97], 'text': ['1976']}, 'id': '56e10a3be3433e1400422b22'}]\n    >>> squad_v2_metric = datasets.load_metric(\"squad_v2\")\n    >>> results = squad_v2_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact': 100.0, 'f1': 100.0, 'total': 1, 'HasAns_exact': 100.0, 'HasAns_f1': 100.0, 'HasAns_total': 1, 'best_exact': 100.0, 'best_exact_thresh': 0.0, 'best_f1': 100.0, 'best_f1_thresh': 0.0}\n"




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,							_KWARGS_DESCRIPTION  )
class        __lowercase(       datasets.Metric  ):






						def 		lowerCAmelCase   (					self)			->  int:




											"""simple docstring"""





											return datasets.MetricInfo(
											    description=_DESCRIPTION    ,						citation=_CITATION    ,						inputs_description=_KWARGS_DESCRIPTION    ,						features=datasets.Features(
											        {
											            'predictions': {
											                'id': datasets.Value('string'),
											                'prediction_text': datasets.Value('string'),
											                'no_answer_probability': datasets.Value('float32'),
											            },
											            'references': {
											                'id': datasets.Value('string'),
											                'answers': datasets.features.Sequence(
											                    {'text': datasets.Value('string'), 'answer_start': datasets.Value('int32')}),
											            },
											        })    ,						codebase_urls=['https://rajpurkar.github.io/SQuAD-explorer/']    ,						reference_urls=['https://rajpurkar.github.io/SQuAD-explorer/']    ,						)






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE=1.0)			->  Optional[int]:




											"""simple docstring"""





											lowerCamelCase__				={p['id']: p['no_answer_probability'] for p in predictions}
											lowerCamelCase__				=[{'paragraphs': [{'qas': references}]}]
											lowerCamelCase__				={p['id']: p['prediction_text'] for p in predictions}

											lowerCamelCase__				=make_qid_to_has_ans(_SCREAMING_SNAKE_CASE)  # maps qid to True/False
											lowerCamelCase__				=[k for k, v in qid_to_has_ans.items() if v]
											lowerCamelCase__				=[k for k, v in qid_to_has_ans.items() if not v]

											lowerCamelCase__				,     lowerCamelCase__				=get_raw_scores(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=apply_no_ans_threshold(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=apply_no_ans_threshold(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=make_eval_dict(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)

											if has_ans_qids:
																lowerCamelCase__				=make_eval_dict(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						qid_list=_SCREAMING_SNAKE_CASE)
																merge_eval(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						'HasAns')
											if no_ans_qids:
																lowerCamelCase__				=make_eval_dict(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						qid_list=_SCREAMING_SNAKE_CASE)
																merge_eval(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						'NoAns')
											find_all_best_thresh(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)
											return dict(_SCREAMING_SNAKE_CASE)