



import logging
from pathlib import Path
from typing import Any, List, Tuple

import yaml


# loading package files: https://stackoverflow.com/a/20885799
try:
						import importlib.resources as pkg_resources
except ImportError:
						# Try backported to PY<37 `importlib_resources`.
						import importlib_resources as pkg_resources

from . import resources


A__						:						Any          =      '''https://github.com/huggingface/datasets/tree/main/src/datasets/utils'''
A__						:						Tuple          =      F'''{BASE_REF_URL}/{__file__}'''
A__						:						List[Any]          =      logging.getLogger(__name__)


def     UpperCamelCase(						__UpperCamelCase							:	str				):
		lowerCAmelCase_    :  Optional[int]             =				pkg_resources.read_text(__UpperCamelCase  ,__UpperCamelCase				)
		return yaml.safe_load(__UpperCamelCase				), f"""{BASE_REF_URL}/resources/{resource}"""


A__      ,  A__						:						List[Any]          =      load_yaml_resource('''readme_structure.yaml''')

A__						:						List[Any]          =      [
    '''[Needs More Information]''',
    '''[More Information Needed]''',
    '''(https://github.com/huggingface/datasets/blob/main/CONTRIBUTING.md#how-to-contribute-to-the-dataset-cards)''',
]

# Dictionary representation of section/readme, error_list, warning_list
A__						:						List[str]          =      Tuple[dict, List[str], List[str]]



class        __snake_case		:




							def __init__( self  : List[str]       ,       A_  : str       ,       A_  : str       ,       A_  : List[str] = None       ,       A_  : bool = False):
									lowerCAmelCase_    :  Dict             =				name
									lowerCAmelCase_    :  List[Any]             =				level
									lowerCAmelCase_    :  Dict             =				lines
									lowerCAmelCase_    :  Optional[Any]             =				''''''
									lowerCAmelCase_    :  str             =				True
									lowerCAmelCase_    :  Union[str, Any]             =				{}
									lowerCAmelCase_    :  Optional[int]             =				[]
									lowerCAmelCase_    :  Optional[Any]             =				[]
									if self.lines is not None:
											self.parse(suppress_parsing_errors=A_)




							def      UpperCAmelCase__    ( self  : Optional[Any]       ,       A_  : bool = False):
									lowerCAmelCase_    :  Any             =				''''''
									lowerCAmelCase_    :  Union[str, Any]             =				[]
									lowerCAmelCase_    :  Tuple             =				False
									for line in self.lines:
											if line.strip(''' \n''') == "":
													continue
											elif line.strip(''' \n''')[:3] == "```":
													lowerCAmelCase_    :  Tuple             =				not code_start
											elif line.split()[0] == self.level + "#" and not code_start:
													if current_sub_level != "":
															lowerCAmelCase_    :  Optional[Any]             =				Section(A_       ,       self.level + '''#'''       ,       A_)
															lowerCAmelCase_    :  Tuple             =				[]
													else:
															if current_lines != []:
																	self.text += "".join(A_).strip()
																	if self.text != "" and self.text not in FILLER_TEXT:
																			lowerCAmelCase_    :  List[Any]             =				False
																	lowerCAmelCase_    :  Union[str, Any]             =				[]

													lowerCAmelCase_    :  List[Any]             =				''' '''.join(line.split()[1:]).strip(''' \n''')
											else:
													current_lines.append(A_)
									else:
											if current_sub_level != "":
													if current_sub_level in self.content:
															self.parsing_error_list.append(
															    F"""Multiple sections with the same heading `{current_sub_level}` have been found. Please keep only one of these sections.""")
													lowerCAmelCase_    :  Union[str, Any]             =				Section(A_       ,       self.level + '''#'''       ,       A_)
											else:
													if current_lines != []:
															self.text += "".join(A_).strip()
															if self.text != "" and self.text not in FILLER_TEXT:
																	lowerCAmelCase_    :  List[Any]             =				False

									if self.level == "" and not suppress_parsing_errors:
											if self.parsing_error_list != [] or self.parsing_warning_list != []:
													lowerCAmelCase_    :  str             =				'''\n'''.join('''-\t''' + x for x in self.parsing_error_list + self.parsing_warning_list)
													lowerCAmelCase_    :  Union[str, Any]             =				F"""The following issues were found while parsing the README at `{self.name}`:\n""" + errors
													raise ValueError(A_)




							def      UpperCAmelCase__    ( self  : List[Any]       ,       A_  : dict):
									lowerCAmelCase_    :  Dict             =				[]
									lowerCAmelCase_    :  List[Any]             =				[]
									if structure["allow_empty"] is False:
											# If content is expected
											if self.is_empty_text and self.content == {}:
													# If no content is found, mention it in the error_list
													error_list.append(F"""Expected some content in section `{self.name}` but it is empty.""")

									if structure["allow_empty_text"] is False:
											# If some text is expected
											if self.is_empty_text:
													# If no text is found, mention it in the error_list
													error_list.append(
													    F"""Expected some text in section `{self.name}` but it is empty (text in subsections are ignored).""")
        # Subsections Validation
									if structure["subsections"] is not None:
											# If subsections are expected
											if self.content == {}:
													# If no subsections are present
													lowerCAmelCase_    :  int             =				[subsection['''name'''] for subsection in structure['''subsections''']]
													# Mention the expected values in the error_list
													error_list.append(
													    F"""Section `{self.name}` expected the following subsections: {", ".join(["`"+x+"`" for x in values])}. Found 'None'.""")
											else:
													# If some subsections are present
													lowerCAmelCase_    :  List[str]             =				[subsection['''name'''] for subsection in structure['''subsections''']]
													lowerCAmelCase_    :  Any             =				False
													for idx, name in enumerate(A_):
															if name not in self.content:
																	# If the expected subsection is not present
																	error_list.append(F"""Section `{self.name}` is missing subsection: `{name}`.""")
																	lowerCAmelCase_    :  Optional[int]             =				True
															else:
																	# If the subsection is present, validate subsection, return the result
																	# and concat the errors from subsection to section error_list

																	# Skip sublevel validation if current level is `###`
																	if self.level == "###":
																			continue
																	else:
																			lowerCAmelCase_      ,						lowerCAmelCase_      ,						lowerCAmelCase_    :  int             =				self.content[name].validate(
																			    structure['''subsections'''][idx])
																	error_list += subsec_error_list
																	warning_list += subsec_warning_list

													if has_missing_subsections:  # we only allow to have extra subsections if all the other ones are here
															for name in self.content:
																	if name not in structure_names:
																			# If an extra subsection is present
																			warning_list.append(
																			    F"""`{self.name}` has an extra subsection: `{name}`. Skipping further validation checks for this subsection as expected structure is unknown.""")
									if error_list:
											# If there are errors, do not return the dictionary as it is invalid
											return {}, error_list, warning_list
									else:
											return self.to_dict(), error_list, warning_list







							def      UpperCAmelCase__    ( self  : int):
									return {
									    "name": self.name,
									    "text": self.text,
									    "is_empty_text": self.is_empty_text,
									    "subsections": [value.to_dict() for value in self.content.values()],
									}





class        __snake_case		(  UpperCamelCase_		):  # Level 0




							def __init__( self  : List[Any]       ,       A_  : str       ,       A_  : List[str]       ,       A_  : dict = None       ,       A_  : bool = False):
									super().__init__(name=A_       ,       level='''''')  # Not using lines here as we need to use a child class parse
									lowerCAmelCase_    :  Optional[int]             =				structure
									lowerCAmelCase_    :  Any             =				-2
									lowerCAmelCase_    :  Union[str, Any]             =				0
									lowerCAmelCase_    :  Dict             =				lines
									if self.lines is not None:
											self.parse(suppress_parsing_errors=A_)




							def      UpperCAmelCase__    ( self  : Any):
									if self.structure is None:
											lowerCAmelCase_      ,						lowerCAmelCase_      ,						lowerCAmelCase_    :  Optional[Any]             =				self._validate(A_)
									else:
											lowerCAmelCase_      ,						lowerCAmelCase_      ,						lowerCAmelCase_    :  Union[str, Any]             =				self._validate(self.structure)
									if error_list != [] or warning_list != []:
											lowerCAmelCase_    :  Optional[Any]             =				'''\n'''.join(['''-\t''' + x for x in error_list + warning_list])
											lowerCAmelCase_    :  Optional[Any]             =				F"""The following issues were found for the README at `{self.name}`:\n""" + errors
											raise ValueError(A_)




							@classmethod
							def      UpperCAmelCase__    ( cls  : str       ,       A_  : Path       ,       A_  : dict = None       ,       A_  : bool = False):
									with open(A_       ,       encoding='''utf-8''') as f:
											lowerCAmelCase_    :  Optional[Any]             =				f.readlines()
									return cls(A_       ,       A_       ,       A_       ,       suppress_parsing_errors=A_)




							@classmethod
							def      UpperCAmelCase__    ( cls  : Tuple       ,       A_  : str       ,       A_  : dict = None       ,       A_  : str = "root"       ,       A_  : bool = False):
									lowerCAmelCase_    :  Dict             =				string.split('''\n''')
									return cls(A_       ,       A_       ,       A_       ,       suppress_parsing_errors=A_)




							def      UpperCAmelCase__    ( self  : Dict       ,       A_  : bool = False):
									# Skip Tags
									lowerCAmelCase_    :  Any             =				0

									for line in self.lines:
											self.yaml_tags_line_count += 1
											if line.strip(''' \n''') == "---":
													self.tag_count += 1
													if self.tag_count == 2:
															break
											line_count += 1
									if self.tag_count == 2:
											lowerCAmelCase_    :  Dict             =				self.lines[line_count + 1 :]  # Get the last + 1 th item.
									else:
											lowerCAmelCase_    :  List[Any]             =				self.lines[self.tag_count :]
									super().parse(suppress_parsing_errors=A_)




							def __str__( self  : Tuple):
									return str(self.to_dict())







							def      UpperCAmelCase__    ( self  : Optional[Any]       ,       A_  : List[str]):
									lowerCAmelCase_    :  Union[str, Any]             =				[]
									lowerCAmelCase_    :  Any             =				[]
									if self.yaml_tags_line_count == 0:
											warning_list.append('''Empty YAML markers are present in the README.''')
									elif self.tag_count == 0:
											warning_list.append('''No YAML markers are present in the README.''')
									elif self.tag_count == 1:
											warning_list.append('''Only the start of YAML tags present in the README.''')
									# Check how many first level sections are present.
									lowerCAmelCase_    :  Optional[int]             =				len(self.content.keys())
									if num_first_level_keys > 1:
											# If more than one, add to the error list, continue
											error_list.append(
											    F"""The README has several first-level headings: {", ".join(["`"+x+"`" for x in list(self.content.keys())])}. Only one heading is expected. Skipping further validation for this README.""")
									elif num_first_level_keys < 1:
											# If less than one, append error.
											error_list.append(
											    '''The README has no first-level headings. One heading is expected. Skipping further validation for this README.''')

									else:
											# If one exactly
											lowerCAmelCase_    :  int             =				list(self.content.keys())[0]  # Get the key
											if start_key.startswith('''Dataset Card for'''):  # Check correct start
													# If the starting is correct, validate all the sections
													lowerCAmelCase_      ,						lowerCAmelCase_      ,						lowerCAmelCase_    :  Union[str, Any]             =				self.content[start_key].validate(
													    readme_structure['''subsections'''][0])
													error_list += sec_error_list
													warning_list += sec_warning_list
											else:
													# If not found, append error
													error_list.append(
													    '''No first-level heading starting with `Dataset Card for` found in README. Skipping further validation for this README.''')
									if error_list:
											# If there are errors, do not return the dictionary as it is invalid
											return {}, error_list, warning_list
									else:
											return self.to_dict(), error_list, warning_list


if __name__ == "__main__":
						from argparse import ArgumentParser

						A__						:						Optional[int]          =      ArgumentParser(usage='''Validate the content (excluding YAML tags) of a README.md file.''')
						ap.add_argument('''readme_filepath''')
						A__						:						List[Any]          =      ap.parse_args()
						A__						:						Optional[int]          =      Path(args.readme_filepath)
						A__						:						List[Any]          =      ReadMe.from_readme(readme_filepath)










from collections import OrderedDict
from typing import Mapping

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


A__						:						int          =      logging.get_logger(__name__)

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



class        __snake_case		(  UpperCamelCase_		):
							_a       =				'''mega'''




							def __init__( self  : Any       ,       A_  : Dict=3_0_5_2_2       ,       A_  : int=1_2_8       ,       A_  : str=4       ,       A_  : int=2_5_6       ,       A_  : int=1_6       ,       A_  : str=True       ,       A_  : List[str]=6_4       ,       A_  : Optional[Any]=False       ,       A_  : str=-1       ,       A_  : Optional[int]=None       ,       A_  : Tuple=True       ,       A_  : Tuple="scalenorm"       ,       A_  : Optional[Any]=True       ,       A_  : int="silu"       ,       A_  : Optional[int]="softmax"       ,       A_  : Optional[int]=0.1       ,       A_  : Union[str, Any]=0.1       ,       A_  : Any=0.1       ,       A_  : Dict=False       ,       A_  : int=True       ,       A_  : Tuple=2_5_6       ,       A_  : int=True       ,       A_  : List[Any]=0.1       ,       A_  : Optional[Any]=2_0_4_8       ,       A_  : Dict=False       ,       A_  : Dict=2       ,       A_  : Tuple=0.02       ,       A_  : List[Any]=0.2       ,       A_  : str=0.02       ,       A_  : List[str]=1.0       ,       A_  : Union[str, Any]=1       ,       A_  : List[Any]=0       ,       A_  : int=2       ,       A_  : Tuple="rotary"       ,       A_  : Any=None       ,       A_  : Tuple=True       ,       A_  : Any=True       ,       **A_  : Optional[int]       ,       ):
									super().__init__(pad_token_id=A_       ,       bos_token_id=A_       ,       eos_token_id=A_       ,       **A_)

									lowerCAmelCase_    :  Tuple             =				vocab_size
									lowerCAmelCase_    :  str             =				hidden_size
									lowerCAmelCase_    :  Any             =				num_hidden_layers
									lowerCAmelCase_    :  Optional[int]             =				activation
									lowerCAmelCase_    :  Any             =				attention_activation
									lowerCAmelCase_    :  List[Any]             =				intermediate_size
									lowerCAmelCase_    :  Any             =				ema_projection_size
									lowerCAmelCase_    :  Optional[int]             =				bidirectional
									lowerCAmelCase_    :  Tuple             =				shared_representation_size
									lowerCAmelCase_    :  Any             =				use_chunking
									lowerCAmelCase_    :  List[str]             =				chunk_size
									lowerCAmelCase_    :  int             =				truncation
									lowerCAmelCase_    :  Tuple             =				normalize_before_mega
									lowerCAmelCase_    :  Tuple             =				normalization_type
									lowerCAmelCase_    :  List[str]             =				norm_affine
									lowerCAmelCase_    :  List[str]             =				dropout_prob
									lowerCAmelCase_    :  List[str]             =				hidden_dropout_prob
									lowerCAmelCase_    :  Tuple             =				attention_probs_dropout_prob
									lowerCAmelCase_    :  str             =				use_feature_dropout
									lowerCAmelCase_    :  Union[str, Any]             =				use_normalized_ffn
									lowerCAmelCase_    :  Union[str, Any]             =				nffn_hidden_size
									lowerCAmelCase_    :  int             =				normalize_before_ffn
									lowerCAmelCase_    :  Tuple             =				nffn_activation_dropout_prob
									lowerCAmelCase_    :  List[str]             =				max_positions
									lowerCAmelCase_    :  Union[str, Any]             =				add_token_type_embeddings
									lowerCAmelCase_    :  str             =				type_vocab_size
									lowerCAmelCase_    :  int             =				initializer_range
									lowerCAmelCase_    :  str             =				ema_delta_alpha_range
									lowerCAmelCase_    :  Tuple             =				ema_beta_range
									lowerCAmelCase_    :  Any             =				ema_gamma_omega_range
									lowerCAmelCase_    :  Any             =				relative_positional_bias
									lowerCAmelCase_    :  Optional[int]             =				use_cache
									lowerCAmelCase_    :  int             =				classifier_dropout
									lowerCAmelCase_    :  List[Any]             =				add_lm_hidden_dense_layer
									lowerCAmelCase_    :  Optional[Any]             =				1  # not used but required by Hugging Face





class        __snake_case		(  UpperCamelCase_		):




							@property
							def      UpperCAmelCase__    ( self  : Any):
									if self.task == "multiple-choice":
											lowerCAmelCase_    :  Dict             =				{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
									else:
											lowerCAmelCase_    :  int             =				{0: '''batch''', 1: '''sequence'''}
									return OrderedDict(
									    [
									        ('''input_ids''', dynamic_axis),
									        ('''attention_mask''', dynamic_axis),
									    ])





