"""simple docstring"""





from __future__ import annotations

import os


class 					UpperCAmelCase_     :
						lowerCamelCase__		:   List[str]			  =  (
						    "High card",
						    "One pair",
						    "Two pairs",
						    "Three of a kind",
						    "Straight",
						    "Flush",
						    "Full house",
						    "Four of a kind",
						    "Straight flush",
						    "Royal flush",
						)

						lowerCamelCase__		:   Optional[int]			  =  (
						    "",  # placeholder as tuples are zero-indexed
						    "One",
						    "Two",
						    "Three",
						    "Four",
						    "Five",
						    "Six",
						    "Seven",
						    "Eight",
						    "Nine",
						    "Ten",
						    "Jack",
						    "Queen",
						    "King",
						    "Ace",
						)


						def __init__(       self		,      a							)	-> None:






													if not isinstance(a		,      a							):
																				lowercase__      :		Tuple          =     f"""Hand should be of type \'str\': {hand!r}"""
																				raise TypeError(a							)
													# split removes duplicate whitespaces so no need of strip
													if len(hand.split(' '							)							) != 5:
																				lowercase__      :		List[Any]          =     f"""Hand should contain only 5 cards: {hand!r}"""
																				raise ValueError(a							)
													lowercase__      :		Union[str, Any]          =     hand
													lowercase__      :		List[Any]          =     0
													lowercase__      :		Union[str, Any]          =     0
													lowercase__   ,				lowercase__      :		Dict          =     self._internal_state()
													lowercase__      :		int          =     self._get_hand_type()
													lowercase__      :		Tuple          =     self._card_values[0]


						@property
						def 		_UpperCAmelCase	(       self							)	-> Optional[int]:
													return self._hand


						def 		_UpperCAmelCase	(       self		,      a							)	-> str:






													if self._hand_type > other._hand_type:
																				return "Win"
													elif self._hand_type < other._hand_type:
																				return "Loss"
													elif self._first_pair == other._first_pair:
																				if self._second_pair == other._second_pair:
																											return self._compare_cards(a							)
																				else:
																											return "Win" if self._second_pair > other._second_pair else "Loss"
													return "Win" if self._first_pair > other._first_pair else "Loss"


						def 		_UpperCAmelCase	(       self							)	-> str:
													lowercase__      :		Union[str, Any]          =     PokerHand._HAND_NAME[self._hand_type - 1_4]
													lowercase__      :		str          =     PokerHand._CARD_NAME[self._high_card]
													lowercase__      :		str          =     PokerHand._CARD_NAME[self._first_pair]
													lowercase__      :		Tuple          =     PokerHand._CARD_NAME[self._second_pair]
													if self._hand_type in [2_2, 1_9, 1_8]:
																				return name + f""", {high}-high"""
													elif self._hand_type in [2_1, 1_7, 1_5]:
																				return name + f""", {paira}s"""
													elif self._hand_type in [2_0, 1_6]:
																				lowercase__      :		Any          =     'over' if self._hand_type == 2_0 else 'and'
																				return name + f""", {paira}s {join} {paira}s"""
													elif self._hand_type == 2_3:
																				return name
													else:
																				return name + f""", {high}"""


						def 		_UpperCAmelCase	(       self		,      a							)	-> str:






													for index, card_value in enumerate(self._card_values							):
																				if card_value != other._card_values[index]:
																											return "Win" if card_value > other._card_values[index] else "Loss"
													return "Tie"


						def 		_UpperCAmelCase	(       self							)	-> int:






													if self._is_flush():
																				if self._is_five_high_straight() or self._is_straight():
																											return 2_3 if sum(self._card_values							) == 6_0 else 2_2
																				return 1_9
													elif self._is_five_high_straight() or self._is_straight():
																				return 1_8
													return 1_4 + self._is_same_kind()


						def 		_UpperCAmelCase	(       self							)	-> bool:
													return len(self._card_suit							) == 1


						def 		_UpperCAmelCase	(       self							)	-> bool:






													if sorted(self._card_values							) == [2, 3, 4, 5, 1_4]:
																				if self._card_values[0] == 1_4:
																											# Remember, our list is sorted in reverse order
																											lowercase__      :		Dict          =     self._card_values.pop(0							)
																											self._card_values.append(a							)
																				return True
													return False


						def 		_UpperCAmelCase	(       self							)	-> bool:






													for i in range(4							):
																				if self._card_values[i] - self._card_values[i + 1] != 1:
																											return False
													return True


						def 		_UpperCAmelCase	(       self							)	-> int:
													lowercase__      :		List[Any]          =     0
													for i in range(4							):
																				# Compare two cards at a time, if they are same increase 'kind',
																				# add the value of the card to val1, if it is repeating again we
																				# will add 2 to 'kind' as there are now 3 cards with same value.
																				# If we get card of different value than val1, we will do the same
																				# thing with val2
																				if self._card_values[i] == self._card_values[i + 1]:
																											if not vala:
																																		lowercase__      :		str          =     self._card_values[i]
																																		kind += 1
																											elif vala == self._card_values[i]:
																																		kind += 2
																											elif not vala:
																																		lowercase__      :		Union[str, Any]          =     self._card_values[i]
																																		kind += 1
																											elif vala == self._card_values[i]:
																																		kind += 2
        # For consistency in hand type (look at note in _get_hand_type function)
													lowercase__      :		Tuple          =     kind + 2 if kind in [4, 5] else kind
													# first meaning first pair to compare in 'compare_with'
													lowercase__      :		Dict          =     max(a		,      a							)
													lowercase__      :		Optional[Any]          =     min(a		,      a							)
													# If it's full house (three count pair + two count pair), make sure
													# first pair is three count and if not then switch them both.
													if kind == 6 and self._card_values.count(a							) != 3:
																				lowercase__   ,				lowercase__      :		Tuple          =     second, first
													lowercase__      :		List[str]          =     first
													lowercase__      :		Dict          =     second
													return kind


						def 		_UpperCAmelCase	(       self							)	-> tuple[list[int], set[str]]:
													lowercase__      :		Optional[int]          =     {'T': '10', 'J': '11', 'Q': '12', 'K': '13', 'A': '14'}
													lowercase__      :		Optional[int]          =     self._hand.translate(str.maketrans(a							)							).split()
													lowercase__      :		int          =     [int(card[:-1]							) for card in new_hand]
													lowercase__      :		List[str]          =     {card[-1] for card in new_hand}
													return sorted(a		,      reverse=a							), card_suit


						def __repr__(       self							)	-> Any:
													return f"""{self.__class__}(\"{self._hand}\")"""


						def __str__(       self							)	-> str:
													return self._hand


						def __eq__(       self		,      a							)	-> int:






													if isinstance(a		,      a							):
																				return self.compare_with(a							) == "Tie"
													return NotImplemented


						def __lt__(       self		,      a							)	-> List[Any]:






													if isinstance(a		,      a							):
																				return self.compare_with(a							) == "Loss"
													return NotImplemented


						def __le__(       self		,      a							)	-> Tuple:






													if isinstance(a		,      a							):
																				return self < other or self == other
													return NotImplemented


						def __gt__(       self		,      a							)	-> int:






													if isinstance(a		,      a							):
																				return not self < other and self != other
													return NotImplemented


						def __ge__(       self		,      a							)	-> int:






													if isinstance(a		,      a							):
																				return not self < other
													return NotImplemented


						def __hash__(       self							)	-> int:
													return object.__hash__(self							)





def     a_					(				):





							'''simple docstring'''

							lowercase__      :		List[Any]          =     0
							lowercase__      :		Dict          =     os.path.abspath(os.path.dirname(SCREAMING_SNAKE_CASE_					)					)
							lowercase__      :		int          =     os.path.join(SCREAMING_SNAKE_CASE_       ,			'poker_hands.txt'					)
							with open(SCREAMING_SNAKE_CASE_					) as file_hand:
														for line in file_hand:
																					lowercase__      :		str          =     line[:14].strip()
																					lowercase__      :		Optional[int]          =     line[15:].strip()
																					lowercase__   ,				lowercase__      :		Union[str, Any]          =     PokerHand(SCREAMING_SNAKE_CASE_					), PokerHand(SCREAMING_SNAKE_CASE_					)
																					lowercase__      :		int          =     player.compare_with(SCREAMING_SNAKE_CASE_					)
																					if output == "Win":
																												answer += 1
							return answer


if __name__ == "__main__":
							solution()


"""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       :						Optional[int]     =   "https://github.com/huggingface/datasets/tree/main/src/datasets/utils"
_UpperCamelCase       :						Union[str, Any]     =   f'''{BASE_REF_URL}/{__file__}'''
_UpperCamelCase       :						Any     =   logging.getLogger(__name__)





def     a_					(				_lowerCAmelCase  :			str					):





       '''simple docstring'''

       lowercase__      :		Optional[Any]          =     pkg_resources.read_text(_lowerCAmelCase       ,			_lowerCAmelCase					)
       return yaml.safe_load(_lowerCAmelCase					), f"""{BASE_REF_URL}/resources/{resource}"""


_UpperCamelCase   ,				_UpperCamelCase       :						int     =   load_yaml_resource("readme_structure.yaml")

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


class 					UpperCAmelCase_     :


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


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

                           lowercase__      :		Dict          =     ' '.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."""							)
                           lowercase__      :		Tuple          =     Section(a		,      self.level + '#'		,      a							)
                    else:
                           if current_lines != []:
                                  self.text += "".join(a							).strip()
                                  if self.text != "" and self.text not in FILLER_TEXT:
                                         lowercase__      :		Dict          =     False

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


      def 		_UpperCAmelCase	(       self		,      a							)	-> ReadmeValidatorOutput:
             lowercase__      :		Tuple          =     []
             lowercase__      :		int          =     []
             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
                           lowercase__      :		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
                           lowercase__      :		Union[str, Any]          =     [subsection['name'] for subsection in structure['subsections']]
                           lowercase__      :		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}`."""							)
                                         lowercase__      :		str          =     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:
                                                lowercase__   ,				lowercase__   ,				lowercase__      :		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 		_UpperCAmelCase	(       self							)	-> dict:
             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 					UpperCAmelCase_     (   _a):  # Level 0


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


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


      @classmethod
      def 		_UpperCAmelCase	(       cls		,      a		,      a = None		,      a = False							)	-> Tuple:
             with open(a		,      encoding='utf-8'							) as f:
                    lowercase__      :		List[Any]          =     f.readlines()
             return cls(a		,      a		,      a		,      suppress_parsing_errors=a							)


      @classmethod
      def 		_UpperCAmelCase	(       cls		,      a		,      a = None		,      a = "root"		,      a = False							)	-> int:
             lowercase__      :		Optional[Any]          =     string.split('\n'							)
             return cls(a		,      a		,      a		,      suppress_parsing_errors=a							)


      def 		_UpperCAmelCase	(       self		,      a = False							)	-> List[Any]:
             # Skip Tags
             lowercase__      :		Tuple          =     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:
                    lowercase__      :		Optional[int]          =     self.lines[line_count + 1 :]  # Get the last + 1 th item.
             else:
                    lowercase__      :		List[str]          =     self.lines[self.tag_count :]
             super().parse(suppress_parsing_errors=a							)


      def __str__(       self							)	-> Any:
             return str(self.to_dict()							)


      def 		_UpperCAmelCase	(       self		,      a							)	-> str:
             lowercase__      :		Any          =     []
             lowercase__      :		Optional[int]          =     []
             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.
             lowercase__      :		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
                    lowercase__      :		Dict          =     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
                           lowercase__   ,				lowercase__   ,				lowercase__      :		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

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

