
'''simple docstring'''





import enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


UpperCAmelCase            = set()
UpperCAmelCase            = get_logger(__name__)

def   A			(							A_				:       Optional[str] = None							):

						def decorator(A_				:       Callable							):
												global _emitted_deprecation_warnings

												if inspect.isclass(A_							):
																		snake_case							:  Tuple			=     deprecated_class_or_function.__init__
																		snake_case							:  Union[str, Any]			=     deprecated_class_or_function.__name__
												else:
																		snake_case							:  Tuple			=     deprecated_class_or_function
																		snake_case							:  Dict			=     deprecated_function.__name__
																		# Support deprecating __init__ class method: class name instead
																		snake_case							:  List[Any]			=     name if name != '''__init__''' else deprecated_function.__qualname__.split('''.'''							)[-2]

												snake_case							:  Optional[int]			=     (
												    F"""{name} is deprecated and will be removed in the next major version of datasets.""" + F""" {help_message}"""
												    if help_message
												    else ''''''
												)

												@wraps(A_							)
												def wrapper(*A_				:       Union[str, Any]     ,				**A_				:       str							):
																		snake_case							:  Tuple			=     hash(A_							)
																		if func_hash not in _emitted_deprecation_warnings:
																								warnings.warn(A_     ,				category=A_     ,				stacklevel=2							)
																								_emitted_deprecation_warnings.add(A_							)
																		return deprecated_function(*A_     ,				**A_							)

												snake_case							:  int			=     '''deprecated'''

												if inspect.isclass(A_							):
																		snake_case							:  Tuple			=     wrapper
																		return deprecated_class_or_function
												else:
																		return wrapper

						return decorator

class     a (					enum.EnumMeta     ):




				def __getattribute__(				cls						:					List[str],     SCREAMING_SNAKE_CASE_						:					Union[str, Any]   ):
										snake_case							:  str			=     super().__getattribute__(SCREAMING_SNAKE_CASE_   )
										if isinstance(SCREAMING_SNAKE_CASE_,     enum.Enum   ) and obj._on_access:
																obj._on_access()
										return obj




				def __getitem__(				cls						:					Tuple,     SCREAMING_SNAKE_CASE_						:					str   ):
										snake_case							:  Union[str, Any]			=     super().__getitem__(SCREAMING_SNAKE_CASE_   )
										if member._on_access:
																member._on_access()
										return member




				def __call__(				cls						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Tuple,     SCREAMING_SNAKE_CASE_						:					Optional[int]=None,     *, SCREAMING_SNAKE_CASE_						:					Dict=None,     SCREAMING_SNAKE_CASE_						:					str=None,     SCREAMING_SNAKE_CASE_						:					Optional[int]=None,     SCREAMING_SNAKE_CASE_						:					Optional[int]=1   ):
										snake_case							:  str			=     super().__call__(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     module=SCREAMING_SNAKE_CASE_,     qualname=SCREAMING_SNAKE_CASE_,     type=SCREAMING_SNAKE_CASE_,     start=SCREAMING_SNAKE_CASE_   )
										if isinstance(SCREAMING_SNAKE_CASE_,     enum.Enum   ) and obj._on_access:
																obj._on_access()
										return obj




class     a (					enum.Enum					,metaclass=__magic_name__     ):




				def __new__(				cls						:					Optional[int],     SCREAMING_SNAKE_CASE_						:					List[Any]   ):
										snake_case							:  Union[str, Any]			=     object.__new__(cls   )
										snake_case							:  List[str]			=     value
										snake_case							:  List[str]			=     member.deprecate
										return member




				@property
				def 						__snake_case				(				self						:					Any   ):
										return ""




				def 						__snake_case				(				self						:					int   ):
										snake_case							:  Union[str, Any]			=     F""" {self.help_message}""" if self.help_message else ''''''
										warnings.warn(
										    F"""'{self.__objclass__.__name__}' is deprecated and will be removed in the next major version of datasets."""
										    + help_message,     SCREAMING_SNAKE_CASE_,     stacklevel=3,     )





from collections import OrderedDict
from typing import Mapping

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


UpperCamelCase			:					List[Any]         =							logging.get_logger(__name__)

UpperCamelCase			:					Tuple         =							{
    '''mnaylor/mega-base-wikitext''': '''https://huggingface.co/mnaylor/mega-base-wikitext/resolve/main/config.json''',
}

class      __snake_case				(   _UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:       str								=			"mega"
					def __init__(						self       :						Optional[int]	,      _lowerCAmelCase       :						List[Any]=3_0_5_2_2	,      _lowerCAmelCase       :						List[str]=1_2_8	,      _lowerCAmelCase       :						Dict=4	,      _lowerCAmelCase       :						Optional[Any]=2_5_6	,      _lowerCAmelCase       :						Optional[Any]=1_6	,      _lowerCAmelCase       :						Dict=True	,      _lowerCAmelCase       :						Optional[Any]=6_4	,      _lowerCAmelCase       :						Optional[Any]=False	,      _lowerCAmelCase       :						Optional[int]=-1	,      _lowerCAmelCase       :						Any=None	,      _lowerCAmelCase       :						List[Any]=True	,      _lowerCAmelCase       :						List[Any]="scalenorm"	,      _lowerCAmelCase       :						str=True	,      _lowerCAmelCase       :						Union[str, Any]="silu"	,      _lowerCAmelCase       :						Optional[Any]="softmax"	,      _lowerCAmelCase       :						Optional[Any]=0.1	,      _lowerCAmelCase       :						Dict=0.1	,      _lowerCAmelCase       :						Any=0.1	,      _lowerCAmelCase       :						Optional[Any]=False	,      _lowerCAmelCase       :						Any=True	,      _lowerCAmelCase       :						int=2_5_6	,      _lowerCAmelCase       :						List[str]=True	,      _lowerCAmelCase       :						str=0.1	,      _lowerCAmelCase       :						List[str]=2_0_4_8	,      _lowerCAmelCase       :						Optional[Any]=False	,      _lowerCAmelCase       :						str=2	,      _lowerCAmelCase       :						Dict=0.02	,      _lowerCAmelCase       :						str=0.2	,      _lowerCAmelCase       :						List[str]=0.02	,      _lowerCAmelCase       :						int=1.0	,      _lowerCAmelCase       :						Optional[int]=1	,      _lowerCAmelCase       :						List[str]=0	,      _lowerCAmelCase       :						str=2	,      _lowerCAmelCase       :						Optional[Any]="rotary"	,      _lowerCAmelCase       :						int=None	,      _lowerCAmelCase       :						int=True	,      _lowerCAmelCase       :						Optional[Any]=True	,      **_lowerCAmelCase       :						str	,      )							->					Any:



											'''simple docstring'''





											super().__init__(pad_token_id=_lowerCAmelCase	,      bos_token_id=_lowerCAmelCase	,      eos_token_id=_lowerCAmelCase	,      **_lowerCAmelCase  )

											__magic_name__					=      vocab_size
											__magic_name__					=      hidden_size
											__magic_name__					=      num_hidden_layers
											__magic_name__					=      activation
											__magic_name__					=      attention_activation
											__magic_name__					=      intermediate_size
											__magic_name__					=      ema_projection_size
											__magic_name__					=      bidirectional
											__magic_name__					=      shared_representation_size
											__magic_name__					=      use_chunking
											__magic_name__					=      chunk_size
											__magic_name__					=      truncation
											__magic_name__					=      normalize_before_mega
											__magic_name__					=      normalization_type
											__magic_name__					=      norm_affine
											__magic_name__					=      dropout_prob
											__magic_name__					=      hidden_dropout_prob
											__magic_name__					=      attention_probs_dropout_prob
											__magic_name__					=      use_feature_dropout
											__magic_name__					=      use_normalized_ffn
											__magic_name__					=      nffn_hidden_size
											__magic_name__					=      normalize_before_ffn
											__magic_name__					=      nffn_activation_dropout_prob
											__magic_name__					=      max_positions
											__magic_name__					=      add_token_type_embeddings
											__magic_name__					=      type_vocab_size
											__magic_name__					=      initializer_range
											__magic_name__					=      ema_delta_alpha_range
											__magic_name__					=      ema_beta_range
											__magic_name__					=      ema_gamma_omega_range
											__magic_name__					=      relative_positional_bias
											__magic_name__					=      use_cache
											__magic_name__					=      classifier_dropout
											__magic_name__					=      add_lm_hidden_dense_layer
											__magic_name__					=      1  # not used but required by Hugging Face







class      __snake_case				(   _UpperCAmelCase):
					@property
					def 	a			(						self       :						int  )							->					Mapping[str, Mapping[int, str]]:



											'''simple docstring'''





											if self.task == "multiple-choice":
																	__magic_name__					=      {0: 'batch', 1: 'choice', 2: 'sequence'}
											else:
																	__magic_name__					=      {0: 'batch', 1: 'sequence'}
											return OrderedDict(
											    [
											        ('input_ids', dynamic_axis),
											        ('attention_mask', dynamic_axis),
											    ]  )

