

"""simple docstring"""





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


__UpperCamelCase						:   int							   =	'''https://github.com/huggingface/datasets/tree/main/src/datasets/utils'''
__UpperCamelCase						:   Tuple							   =	F'''{BASE_REF_URL}/{__file__}'''
__UpperCamelCase						:   str							   =	logging.getLogger(__name__)

def 						__SCREAMING_SNAKE_CASE						(   A_				):
	lowerCAmelCase__			:		Optional[Any]						       =			pkg_resources.read_text(A_		,  A_				)
	return yaml.safe_load(A_				), f'{BASE_REF_URL}/resources/{resource}'


__UpperCamelCase   ,					__UpperCamelCase						:   Tuple							   =	load_yaml_resource('''readme_structure.yaml''')

__UpperCamelCase						:   List[str]							   =	[
    '''[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
__UpperCamelCase						:   Any							   =	Tuple[dict, List[str], List[str]]







class        SCREAMING_SNAKE_CASE      :






					"""simple docstring"""



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







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

								lowerCAmelCase__			:		int						       =			''' '''.join(line.split()[1:]	).strip(''' \n'''	)
							else:
								current_lines.append(lowercase_	)
						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__			:		Tuple						       =			Section(lowercase_     ,self.level + '''#'''     ,lowercase_	)
							else:
								if current_lines != []:
									self.text += "".join(lowercase_	).strip()
									if self.text != "" and self.text not in FILLER_TEXT:
										lowerCAmelCase__			:		Dict						       =			False

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







					def  __lowerCAmelCase				( self    :       str     ,lowercase_    :       dict	):
						lowerCAmelCase__			:		List[Any]						       =			[]
						lowerCAmelCase__			:		List[str]						       =			[]
						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__			:		List[str]						       =			[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__			:		Tuple						       =			[subsection['''name'''] for subsection in structure['''subsections''']]
								lowerCAmelCase__			:		int						       =			False
								for idx, name in enumerate(lowercase_	):
									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__			:		Any						       =			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__			:		Optional[Any]						       =			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  __lowerCAmelCase				( self    :       List[str]	):
						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        SCREAMING_SNAKE_CASE      (	a_ ):  # Level 0






					"""simple docstring"""



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







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







					@classmethod
					def  __lowerCAmelCase				( cls    :       Optional[Any]     ,lowercase_    :       Path     ,lowercase_    :       dict = None     ,lowercase_    :       bool = False	):
						with open(lowercase_     ,encoding='''utf-8'''	) as f:
							lowerCAmelCase__			:		Dict						       =			f.readlines()
						return cls(lowercase_     ,lowercase_     ,lowercase_     ,suppress_parsing_errors=lowercase_	)







					@classmethod
					def  __lowerCAmelCase				( cls    :       Union[str, Any]     ,lowercase_    :       str     ,lowercase_    :       dict = None     ,lowercase_    :       str = "root"     ,lowercase_    :       bool = False	):
						lowerCAmelCase__			:		Optional[Any]						       =			string.split('''\n'''	)
						return cls(lowercase_     ,lowercase_     ,lowercase_     ,suppress_parsing_errors=lowercase_	)







					def  __lowerCAmelCase				( self    :       Union[str, Any]     ,lowercase_    :       bool = False	):
						# Skip Tags
						lowerCAmelCase__			:		Union[str, 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__			:		str						       =			self.lines[line_count + 1 :]  # Get the last + 1 th item.
						else:
							lowerCAmelCase__			:		Optional[int]						       =			self.lines[self.tag_count :]
						super().parse(suppress_parsing_errors=lowercase_	)







					def __str__( self    :       List[str]	):
						return str(self.to_dict()	)







					def  __lowerCAmelCase				( self    :       Optional[int]     ,lowercase_    :       Tuple	):
						lowerCAmelCase__			:		Union[str, Any]						       =			[]
						lowerCAmelCase__			:		List[str]						       =			[]
						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__			:		Tuple						       =			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__			:		Tuple						       =			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__			:		Tuple						       =			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

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







"""simple docstring"""





import random
import sys

__UpperCamelCase						:   Tuple							   =	'''ABCDEFGHIJKLMNOPQRSTUVWXYZ'''

def 						__SCREAMING_SNAKE_CASE						(   ):
	lowerCAmelCase__			:		List[str]						       =			input('''Enter message: '''				)
	lowerCAmelCase__			:		Optional[int]						       =			'''LFWOAYUISVKMNXPBDCRJTQEGHZ'''
	lowerCAmelCase__			:		List[Any]						       =			input('''Encrypt/Decrypt [e/d]: '''				)

	check_valid_key(A_				)

	if resp.lower().startswith('''e'''				):
		lowerCAmelCase__			:		Tuple						       =			'''encrypt'''
		lowerCAmelCase__			:		Union[str, Any]						       =			encrypt_message(A_		,  A_				)
	elif resp.lower().startswith('''d'''				):
		lowerCAmelCase__			:		Dict						       =			'''decrypt'''
		lowerCAmelCase__			:		str						       =			decrypt_message(A_		,  A_				)

	print(f'\n{mode.title()}ion: \n{translated}'				)

def 						__SCREAMING_SNAKE_CASE						(   A_				):
	lowerCAmelCase__			:		str						       =			list(A_				)
	lowerCAmelCase__			:		int						       =			list(A_				)
	key_list.sort()
	letters_list.sort()

	if key_list != letters_list:
		sys.exit('''Error in the key or symbol set.'''				)

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_				):
	return translate_message(A_		,  A_		,  '''encrypt'''				)

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_				):
	return translate_message(A_		,  A_		,  '''decrypt'''				)

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_		,  A_				):
	lowerCAmelCase__			:		str						       =			''''''
	lowerCAmelCase__			:		List[str]						       =			LETTERS
	lowerCAmelCase__			:		Optional[int]						       =			key

	if mode == "decrypt":
		lowerCAmelCase__       ,lowerCAmelCase__			:		int						       =			chars_b, chars_a

	for symbol in message:
		if symbol.upper() in chars_a:
			lowerCAmelCase__			:		int						       =			chars_a.find(symbol.upper()				)
			if symbol.isupper():
				translated += chars_b[sym_index].upper()
			else:
				translated += chars_b[sym_index].lower()
		else:
			translated += symbol

	return translated

def 						__SCREAMING_SNAKE_CASE						(   ):
	lowerCAmelCase__			:		Optional[int]						       =			list(A_				)
	random.shuffle(A_				)
	return "".join(A_				)


if __name__ == "__main__":
							main()




