



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    	=  '''https://github.com/huggingface/datasets/tree/main/src/datasets/utils'''
__UpperCAmelCase    	=  f"""{BASE_REF_URL}/{__file__}"""
__UpperCAmelCase    	=  logging.getLogger(__name__)





def     __lowerCamelCase							(   __magic_name__						:	str    ):
							a__:							List[Any]									=pkg_resources.read_text(__magic_name__  ,			__magic_name__    )
							return yaml.safe_load(__magic_name__    ), F"{BASE_REF_URL}/resources/{resource}"


__UpperCAmelCase	,				__UpperCAmelCase    	=  load_yaml_resource('''readme_structure.yaml''')

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


class 						lowerCamelCase__			:


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


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

																											a__:							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."      )
																											a__:							List[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:
																																									a__:							Dict									=False

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


						def 	_lowerCamelCase      (			self    :	Any   ,							_a    :	dict      ):
													a__:							List[str]									=[]
													a__:							Optional[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
																											a__:							Optional[Any]									=[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
																											a__:							Dict									=[subsection["name"] for subsection in structure["subsections"]]
																											a__:							Dict									=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}`."      )
																																									a__:							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:
																																																a__				,      a__				,      a__:							Dict									=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[Any]      ):
													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 						lowerCamelCase__			(		_a ):  # Level 0


						def __init__(			self    :	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
													a__:							Optional[int]									=structure
													a__:							str									=-2
													a__:							int									=0
													a__:							List[Any]									=lines
													if self.lines is not None:
																				self.parse(suppress_parsing_errors=_a      )


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


						@classmethod
						def 	_lowerCamelCase      (			cls    :	List[Any]   ,							_a    :	Path   ,							_a    :	dict = None   ,							_a    :	bool = False      ):
													with open(_a   ,							encoding="utf-8"      ) as f:
																				a__:							Dict									=f.readlines()
													return cls(_a   ,							_a   ,							_a   ,							suppress_parsing_errors=_a      )


						@classmethod
						def 	_lowerCamelCase      (			cls    :	Optional[int]   ,							_a    :	str   ,							_a    :	dict = None   ,							_a    :	str = "root"   ,							_a    :	bool = False      ):
													a__:							int									=string.split("\n"      )
													return cls(_a   ,							_a   ,							_a   ,							suppress_parsing_errors=_a      )


						def 	_lowerCamelCase      (			self    :	Optional[Any]   ,							_a    :	bool = False      ):
													# Skip Tags
													a__:							Dict									=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:
																				a__:							Any									=self.lines[line_count + 1 :]  # Get the last + 1 th item.
													else:
																				a__:							Optional[Any]									=self.lines[self.tag_count :]
													super().parse(suppress_parsing_errors=_a      )


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







						def 	_lowerCamelCase      (			self    :	Dict   ,							_a    :	Union[str, Any]      ):
													a__:							int									=[]
													a__:							Union[str, 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.
													a__:							Dict									=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
																				a__:							Optional[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
																											a__				,      a__				,      a__:							Dict									=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    	=  ArgumentParser(usage='''Validate the content (excluding YAML tags) of a README.md file.''')
		ap.add_argument('''readme_filepath''')
		__UpperCAmelCase    	=  ap.parse_args()
		__UpperCAmelCase    	=  Path(args.readme_filepath)
		__UpperCAmelCase    	=  ReadMe.from_readme(readme_filepath)










from __future__ import annotations





def     __lowerCamelCase							(   __magic_name__						:	int    ):
							for r in range(1  ,			__magic_name__    ):
														a__:							List[str]									=[]
														for x in range(n - 1    ):
																					a__:							int									=pow(__magic_name__  ,			__magic_name__  ,			__magic_name__    )
																					if val in li:
																												break
																					li.append(__magic_name__    )
														else:
																					return r
							return None


if __name__ == "__main__":
		__UpperCAmelCase    	=  int(input('''Enter a prime number q: '''))
		__UpperCAmelCase    	=  find_primitive(q)
		if a is None:
				print(f"""Cannot find the primitive for the value: {a!r}""")
		else:
				__UpperCAmelCase    	=  int(input('''Enter private key of A: '''))
				__UpperCAmelCase    	=  pow(a, a_private, q)
				__UpperCAmelCase    	=  int(input('''Enter private key of B: '''))
				__UpperCAmelCase    	=  pow(a, b_private, q)

				__UpperCAmelCase    	=  pow(b_public, a_private, q)
				__UpperCAmelCase    	=  pow(a_public, b_private, q)

				print('''The key value generated by A is: ''', a_secret)
				print('''The key value generated by B is: ''', b_secret)





