code: 
  
  
  
  import os
  import unittest
  
  from transformers import ElectraTokenizerFast
  from transformers.models.electra.tokenization_electra import (
      VOCAB_FILES_NAMES,
      BasicTokenizer,
      ElectraTokenizer,
      WordpieceTokenizer,
      _is_control,
      _is_punctuation,
      _is_whitespace,
  )
  from transformers.testing_utils import require_tokenizers, slow
  
  from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
  
  
  
  
  
  
  @require_tokenizers
  class 	lowercase		(				snake_case__				,					unittest.TestCase):
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      int	     =							ElectraTokenizer
  	a__   :      List[Any]	     =							ElectraTokenizerFast
  	a__   :      Any	     =							True
  	a__   :      Optional[Any]	     =							True
  	a__   :      Dict	     =							filter_non_english
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				str:
  							super().setUp()
  
  							UpperCAmelCase_=     [
  							    """[UNK]""",
  							    """[CLS]""",
  							    """[SEP]""",
  							    """[PAD]""",
  							    """[MASK]""",
  							    """want""",
  							    """##want""",
  							    """##ed""",
  							    """wa""",
  							    """un""",
  							    """runn""",
  							    """##ing""",
  							    """,""",
  							    """low""",
  							    """lowest""",
  							]
  							UpperCAmelCase_=     os.path.join(self.tmpdirname		,						VOCAB_FILES_NAMES["""vocab_file"""]  )
  							with open(self.vocab_file		,						"""w"""		,						encoding="""utf-8"""  ) as vocab_writer:
  													vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]  )  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]		,						__UpperCAmelCase			:		Tuple  )    ->				List[Any]:
  							UpperCAmelCase_=     """UNwant\u00E9d,running"""
  							UpperCAmelCase_=     """unwanted, running"""
  							return input_text, output_text
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]  )    ->				Dict:
  							UpperCAmelCase_=     self.tokenizer_class(self.vocab_file  )
  
  							UpperCAmelCase_=     tokenizer.tokenize("""UNwant\u00E9d,running"""  )
  							self.assertListEqual(__UpperCAmelCase		,						["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""]  )
  							self.assertListEqual(tokenizer.convert_tokens_to_ids(__UpperCAmelCase  )		,						[9, 6, 7, 12, 10, 11]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		int  )    ->				Tuple:
  							if not self.test_rust_tokenizer:
  													return
  
  							UpperCAmelCase_=     self.get_tokenizer()
  							UpperCAmelCase_=     self.get_rust_tokenizer()
  
  							UpperCAmelCase_=     """UNwant\u00E9d,running"""
  
  							UpperCAmelCase_=     tokenizer.tokenize(__UpperCAmelCase  )
  							UpperCAmelCase_=     rust_tokenizer.tokenize(__UpperCAmelCase  )
  							self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  							UpperCAmelCase_=     tokenizer.encode(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase  )
  							UpperCAmelCase_=     rust_tokenizer.encode(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase  )
  							self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  							UpperCAmelCase_=     self.get_rust_tokenizer()
  							UpperCAmelCase_=     tokenizer.encode(__UpperCAmelCase  )
  							UpperCAmelCase_=     rust_tokenizer.encode(__UpperCAmelCase  )
  							self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  							# With lower casing
  							UpperCAmelCase_=     self.get_tokenizer(do_lower_case=__UpperCAmelCase  )
  							UpperCAmelCase_=     self.get_rust_tokenizer(do_lower_case=__UpperCAmelCase  )
  
  							UpperCAmelCase_=     """UNwant\u00E9d,running"""
  
  							UpperCAmelCase_=     tokenizer.tokenize(__UpperCAmelCase  )
  							UpperCAmelCase_=     rust_tokenizer.tokenize(__UpperCAmelCase  )
  							self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  							UpperCAmelCase_=     tokenizer.encode(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase  )
  							UpperCAmelCase_=     rust_tokenizer.encode(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase  )
  							self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  							UpperCAmelCase_=     self.get_rust_tokenizer()
  							UpperCAmelCase_=     tokenizer.encode(__UpperCAmelCase  )
  							UpperCAmelCase_=     rust_tokenizer.encode(__UpperCAmelCase  )
  							self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any  )    ->				Optional[Any]:
  							UpperCAmelCase_=     BasicTokenizer()
  
  							self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz"""  )		,						["""ah""", """\u535A""", """\u63A8""", """zz"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				List[str]:
  							UpperCAmelCase_=     BasicTokenizer(do_lower_case=__UpperCAmelCase  )
  
  							self.assertListEqual(
  							    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """  )		,						["""hello""", """!""", """how""", """are""", """you""", """?"""]  )
  							self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""  )		,						["""hello"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Any:
  							UpperCAmelCase_=     BasicTokenizer(do_lower_case=__UpperCAmelCase		,						strip_accents=__UpperCAmelCase  )
  
  							self.assertListEqual(
  							    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """  )		,						["""hällo""", """!""", """how""", """are""", """you""", """?"""]  )
  							self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""  )		,						["""h\u00E9llo"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]  )    ->				Dict:
  							UpperCAmelCase_=     BasicTokenizer(do_lower_case=__UpperCAmelCase		,						strip_accents=__UpperCAmelCase  )
  
  							self.assertListEqual(
  							    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """  )		,						["""hallo""", """!""", """how""", """are""", """you""", """?"""]  )
  							self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""  )		,						["""hello"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Any:
  							UpperCAmelCase_=     BasicTokenizer(do_lower_case=__UpperCAmelCase  )
  
  							self.assertListEqual(
  							    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """  )		,						["""hallo""", """!""", """how""", """are""", """you""", """?"""]  )
  							self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""  )		,						["""hello"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				int:
  							UpperCAmelCase_=     BasicTokenizer(do_lower_case=__UpperCAmelCase  )
  
  							self.assertListEqual(
  							    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """  )		,						["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any  )    ->				Dict:
  							UpperCAmelCase_=     BasicTokenizer(do_lower_case=__UpperCAmelCase		,						strip_accents=__UpperCAmelCase  )
  
  							self.assertListEqual(
  							    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """  )		,						["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				str:
  							UpperCAmelCase_=     BasicTokenizer(do_lower_case=__UpperCAmelCase		,						strip_accents=__UpperCAmelCase  )
  
  							self.assertListEqual(
  							    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """  )		,						["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				int:
  							UpperCAmelCase_=     BasicTokenizer(do_lower_case=__UpperCAmelCase		,						never_split=["""[UNK]"""]  )
  
  							self.assertListEqual(
  							    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU? [UNK]"""  )		,						["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Tuple  )    ->				List[Any]:
  							UpperCAmelCase_=     ["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""]
  
  							UpperCAmelCase_=     {}
  							for i, token in enumerate(__UpperCAmelCase  ):
  													UpperCAmelCase_=     i
  							UpperCAmelCase_=     WordpieceTokenizer(vocab=__UpperCAmelCase		,						unk_token="""[UNK]"""  )
  
  							self.assertListEqual(tokenizer.tokenize(""""""  )		,						[]  )
  
  							self.assertListEqual(tokenizer.tokenize("""unwanted running"""  )		,						["""un""", """##want""", """##ed""", """runn""", """##ing"""]  )
  
  							self.assertListEqual(tokenizer.tokenize("""unwantedX running"""  )		,						["""[UNK]""", """runn""", """##ing"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]  )    ->				List[Any]:
  							self.assertTrue(_is_whitespace(""" """  )  )
  							self.assertTrue(_is_whitespace("""\t"""  )  )
  							self.assertTrue(_is_whitespace("""\r"""  )  )
  							self.assertTrue(_is_whitespace("""\n"""  )  )
  							self.assertTrue(_is_whitespace("""\u00A0"""  )  )
  
  							self.assertFalse(_is_whitespace("""A"""  )  )
  							self.assertFalse(_is_whitespace("""-"""  )  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]  )    ->				Optional[int]:
  							self.assertTrue(_is_control("""\u0005"""  )  )
  
  							self.assertFalse(_is_control("""A"""  )  )
  							self.assertFalse(_is_control(""" """  )  )
  							self.assertFalse(_is_control("""\t"""  )  )
  							self.assertFalse(_is_control("""\r"""  )  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Dict:
  							self.assertTrue(_is_punctuation("""-"""  )  )
  							self.assertTrue(_is_punctuation("""$"""  )  )
  							self.assertTrue(_is_punctuation("""`"""  )  )
  							self.assertTrue(_is_punctuation("""."""  )  )
  
  							self.assertFalse(_is_punctuation("""A"""  )  )
  							self.assertFalse(_is_punctuation(""" """  )  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				str:
  							UpperCAmelCase_=     self.get_tokenizer()
  							UpperCAmelCase_=     self.get_rust_tokenizer()
  
  							# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
  							self.assertListEqual([tokenizer.tokenize(__UpperCAmelCase  ) for t in ["""Test""", """\xad""", """test"""]]		,						[["""[UNK]"""], [], ["""[UNK]"""]]  )
  
  							self.assertListEqual(
  							    [rust_tokenizer.tokenize(__UpperCAmelCase  ) for t in ["""Test""", """\xad""", """test"""]]		,						[["""[UNK]"""], [], ["""[UNK]"""]]  )
  
  
  
  
  	@slow
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				Tuple:
  							UpperCAmelCase_=     self.tokenizer_class.from_pretrained("""google/electra-base-discriminator"""  )
  
  							UpperCAmelCase_=     tokenizer.encode("""sequence builders"""		,						add_special_tokens=__UpperCAmelCase  )
  							UpperCAmelCase_=     tokenizer.encode("""multi-sequence build"""		,						add_special_tokens=__UpperCAmelCase  )
  
  							UpperCAmelCase_=     tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase  )
  							UpperCAmelCase_=     tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  							assert encoded_sentence == [101] + text + [102]
  							assert encoded_pair == [101] + text + [102] + text_a + [102]
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				Dict:
  							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  													with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""  ):
  																			UpperCAmelCase_=     self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase		,						**__UpperCAmelCase  )
  
  																			UpperCAmelCase_=     F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
  																			UpperCAmelCase_=     tokenizer_r.encode_plus(
  																			    __UpperCAmelCase		,						return_attention_mask=__UpperCAmelCase		,						return_token_type_ids=__UpperCAmelCase		,						return_offsets_mapping=__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase		,						)
  
  																			UpperCAmelCase_=     tokenizer_r.do_lower_case if hasattr(__UpperCAmelCase		,						"""do_lower_case"""  ) else False
  																			UpperCAmelCase_=     (
  																			    [
  																			        ((0, 0), tokenizer_r.cls_token),
  																			        ((0, 1), """A"""),
  																			        ((1, 2), ""","""),
  																			        ((3, 5), """na"""),
  																			        ((5, 6), """##ï"""),
  																			        ((6, 8), """##ve"""),
  																			        ((9, 15), tokenizer_r.mask_token),
  																			        ((16, 21), """Allen"""),
  																			        ((21, 23), """##NL"""),
  																			        ((23, 24), """##P"""),
  																			        ((25, 33), """sentence"""),
  																			        ((33, 34), """."""),
  																			        ((0, 0), tokenizer_r.sep_token),
  																			    ]
  																			    if not do_lower_case
  																			    else [
  																			        ((0, 0), tokenizer_r.cls_token),
  																			        ((0, 1), """a"""),
  																			        ((1, 2), ""","""),
  																			        ((3, 8), """naive"""),
  																			        ((9, 15), tokenizer_r.mask_token),
  																			        ((16, 21), """allen"""),
  																			        ((21, 23), """##nl"""),
  																			        ((23, 24), """##p"""),
  																			        ((25, 33), """sentence"""),
  																			        ((33, 34), """."""),
  																			        ((0, 0), tokenizer_r.sep_token),
  																			    ]
  																			)
  
  																			self.assertEqual(
  																			    [e[1] for e in expected_results]		,						tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""]  )  )
  																			self.assertEqual([e[0] for e in expected_results]		,						tokens["""offset_mapping"""]  )
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[Any]  )    ->				str:
  							UpperCAmelCase_=     ["""的""", """人""", """有"""]
  							UpperCAmelCase_=     """""".join(__UpperCAmelCase  )
  							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  													with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""  ):
  																			UpperCAmelCase_=     True
  																			UpperCAmelCase_=     self.tokenizer_class.from_pretrained(__UpperCAmelCase		,						**__UpperCAmelCase  )
  																			UpperCAmelCase_=     self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase		,						**__UpperCAmelCase  )
  
  																			UpperCAmelCase_=     tokenizer_p.encode(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase  )
  																			UpperCAmelCase_=     tokenizer_r.encode(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase  )
  
  																			UpperCAmelCase_=     tokenizer_r.convert_ids_to_tokens(__UpperCAmelCase  )
  																			UpperCAmelCase_=     tokenizer_p.convert_ids_to_tokens(__UpperCAmelCase  )
  
  																			# it is expected that each Chinese character is not preceded by "##"
  																			self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  																			self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  																			UpperCAmelCase_=     False
  																			UpperCAmelCase_=     self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase		,						**__UpperCAmelCase  )
  																			UpperCAmelCase_=     self.tokenizer_class.from_pretrained(__UpperCAmelCase		,						**__UpperCAmelCase  )
  
  																			UpperCAmelCase_=     tokenizer_r.encode(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase  )
  																			UpperCAmelCase_=     tokenizer_p.encode(__UpperCAmelCase		,						add_special_tokens=__UpperCAmelCase  )
  
  																			UpperCAmelCase_=     tokenizer_r.convert_ids_to_tokens(__UpperCAmelCase  )
  																			UpperCAmelCase_=     tokenizer_p.convert_ids_to_tokens(__UpperCAmelCase  )
  
  																			# it is expected that only the first Chinese character is not preceded by "##".
  																			UpperCAmelCase_=     [
  																			    F"""##{token}""" if idx != 0 else token for idx, token in enumerate(__UpperCAmelCase  )
  																			]
  																			self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  																			self.assertListEqual(__UpperCAmelCase		,						__UpperCAmelCase  )
  
  
  
  
  
style_context: 
  
  
  
  from __future__ import annotations
  
  import os
  
  
  
  
  
  
  class 	lowercase		:
  
  
  
  
  
  
  	"""simple docstring"""
  
  
  	a__   :      List[str]	     =							(
  	    "High card",
  	    "One pair",
  	    "Two pairs",
  	    "Three of a kind",
  	    "Straight",
  	    "Flush",
  	    "Full house",
  	    "Four of a kind",
  	    "Straight flush",
  	    "Royal flush",
  	)
  
  	a__   :      Optional[Any]	     =							(
  	    "",  # placeholder as tuples are zero-indexed
  	    "One",
  	    "Two",
  	    "Three",
  	    "Four",
  	    "Five",
  	    "Six",
  	    "Seven",
  	    "Eight",
  	    "Nine",
  	    "Ten",
  	    "Jack",
  	    "Queen",
  	    "King",
  	    "Ace",
  	)
  
  
  
  
  	def __init__(			self			:		Tuple		,						__UpperCAmelCase			:		str  )    ->				None:
  							if not isinstance(__UpperCAmelCase		,						__UpperCAmelCase  ):
  													UpperCAmelCase_=     F"""Hand should be of type 'str': {hand!r}"""
  													raise TypeError(__UpperCAmelCase  )
  							# split removes duplicate whitespaces so no need of strip
  							if len(hand.split(""" """  )  ) != 5:
  													UpperCAmelCase_=     F"""Hand should contain only 5 cards: {hand!r}"""
  													raise ValueError(__UpperCAmelCase  )
  							UpperCAmelCase_=     hand
  							UpperCAmelCase_=     0
  							UpperCAmelCase_=     0
  							UpperCAmelCase_,     UpperCAmelCase_=     self._internal_state()
  							UpperCAmelCase_=     self._get_hand_type()
  							UpperCAmelCase_=     self._card_values[0]
  
  
  
  
  	@property
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		int  )    ->				Union[str, Any]:
  							return self._hand
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]		,						__UpperCAmelCase			:		PokerHand  )    ->				str:
  							# Breaking the tie works on the following order of precedence:
  							# 1. First pair (default 0)
  							# 2. Second pair (default 0)
  							# 3. Compare all cards in reverse order because they are sorted.
  
  							# First pair and second pair will only be a non-zero value if the card
  							# type is either from the following:
  							# 21: Four of a kind
  							# 20: Full house
  							# 17: Three of a kind
  							# 16: Two pairs
  							# 15: One pair
  							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(__UpperCAmelCase  )
  													else:
  																			return "Win" if self._second_pair > other._second_pair else "Loss"
  							return "Win" if self._first_pair > other._first_pair else "Loss"
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				str:
  							UpperCAmelCase_=     PokerHand._HAND_NAME[self._hand_type - 14]
  							UpperCAmelCase_=     PokerHand._CARD_NAME[self._high_card]
  							UpperCAmelCase_=     PokerHand._CARD_NAME[self._first_pair]
  							UpperCAmelCase_=     PokerHand._CARD_NAME[self._second_pair]
  							if self._hand_type in [22, 19, 18]:
  													return name + F""", {high}-high"""
  							elif self._hand_type in [21, 17, 15]:
  													return name + F""", {paira}s"""
  							elif self._hand_type in [20, 16]:
  													UpperCAmelCase_=     """over""" if self._hand_type == 20 else """and"""
  													return name + F""", {paira}s {join} {paira}s"""
  							elif self._hand_type == 23:
  													return name
  							else:
  													return name + F""", {high}"""
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]		,						__UpperCAmelCase			:		PokerHand  )    ->				str:
  							# Enumerate gives us the index as well as the element of a list
  							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 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]  )    ->				int:
  							# Number representing the type of hand internally:
  							# 23: Royal flush
  							# 22: Straight flush
  							# 21: Four of a kind
  							# 20: Full house
  							# 19: Flush
  							# 18: Straight
  							# 17: Three of a kind
  							# 16: Two pairs
  							# 15: One pair
  							# 14: High card
  							if self._is_flush():
  													if self._is_five_high_straight() or self._is_straight():
  																			return 23 if sum(self._card_values  ) == 60 else 22
  													return 19
  							elif self._is_five_high_straight() or self._is_straight():
  													return 18
  							return 14 + self._is_same_kind()
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				bool:
  							return len(self._card_suit  ) == 1
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[Any]  )    ->				bool:
  							# If a card is a five high straight (low ace) change the location of
  							# ace from the start of the list to the end. Check whether the first
  							# element is ace or not. (Don't want to change again)
  							# Five high straight (low ace): AH 2H 3S 4C 5D
  							# Why use sorted here? One call to this function will mutate the list to
  							# [5, 4, 3, 2, 14] and so for subsequent calls (which will be rare) we
  							# need to compare the sorted version.
  							# Refer test_multiple_calls_five_high_straight in test_poker_hand.py
  							if sorted(self._card_values  ) == [2, 3, 4, 5, 14]:
  													if self._card_values[0] == 14:
  																			# Remember, our list is sorted in reverse order
  																			UpperCAmelCase_=     self._card_values.pop(0  )
  																			self._card_values.append(__UpperCAmelCase  )
  													return True
  							return False
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Tuple  )    ->				bool:
  							for i in range(4  ):
  													if self._card_values[i] - self._card_values[i + 1] != 1:
  																			return False
  							return True
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any  )    ->				int:
  							# Kind Values for internal use:
  							# 7: Four of a kind
  							# 6: Full house
  							# 3: Three of a kind
  							# 2: Two pairs
  							# 1: One pair
  							# 0: False
  							UpperCAmelCase_=     UpperCAmelCase_=     UpperCAmelCase_=     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:
  																									UpperCAmelCase_=     self._card_values[i]
  																									kind += 1
  																			elif vala == self._card_values[i]:
  																									kind += 2
  																			elif not vala:
  																									UpperCAmelCase_=     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)
  							UpperCAmelCase_=     kind + 2 if kind in [4, 5] else kind
  							# first meaning first pair to compare in 'compare_with'
  							UpperCAmelCase_=     max(__UpperCAmelCase		,						__UpperCAmelCase  )
  							UpperCAmelCase_=     min(__UpperCAmelCase		,						__UpperCAmelCase  )
  							# 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(__UpperCAmelCase  ) != 3:
  													UpperCAmelCase_,     UpperCAmelCase_=     second, first
  							UpperCAmelCase_=     first
  							UpperCAmelCase_=     second
  							return kind
  
  
  
  
  	def 						_SCREAMING_SNAKE_CASE	(			self			:		int  )    ->				tuple[list[int], set[str]]:
  							# Internal representation of hand as a list of card values and
  							# a set of card suit
  							UpperCAmelCase_=     {"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
  							UpperCAmelCase_=     self._hand.translate(str.maketrans(__UpperCAmelCase  )  ).split()
  							UpperCAmelCase_=     [int(card[:-1]  ) for card in new_hand]
  							UpperCAmelCase_=     {card[-1] for card in new_hand}
  							return sorted(__UpperCAmelCase		,						reverse=__UpperCAmelCase  ), card_suit
  
  
  
  
  	def __repr__(			self			:		Dict  )    ->				Dict:
  							return F"""{self.__class__}(\"{self._hand}\")"""
  
  
  
  
  	def __str__(			self			:		Tuple  )    ->				List[Any]:
  							return self._hand
  
  
  
  
  	def __eq__(			self			:		List[Any]		,						__UpperCAmelCase			:		Optional[Any]  )    ->				int:
  							if isinstance(__UpperCAmelCase		,						__UpperCAmelCase  ):
  													return self.compare_with(__UpperCAmelCase  ) == "Tie"
  							return NotImplemented
  
  
  
  
  	def __lt__(			self			:		Union[str, Any]		,						__UpperCAmelCase			:		Optional[int]  )    ->				Union[str, Any]:
  							if isinstance(__UpperCAmelCase		,						__UpperCAmelCase  ):
  													return self.compare_with(__UpperCAmelCase  ) == "Loss"
  							return NotImplemented
  
  
  
  
  	def __le__(			self			:		List[str]		,						__UpperCAmelCase			:		Optional[int]  )    ->				Optional[Any]:
  							if isinstance(__UpperCAmelCase		,						__UpperCAmelCase  ):
  													return self < other or self == other
  							return NotImplemented
  
  
  
  
  	def __gt__(			self			:		List[str]		,						__UpperCAmelCase			:		List[str]  )    ->				int:
  							if isinstance(__UpperCAmelCase		,						__UpperCAmelCase  ):
  													return not self < other and self != other
  							return NotImplemented
  
  
  
  
  	def __ge__(			self			:		Union[str, Any]		,						__UpperCAmelCase			:		Tuple  )    ->				Any:
  							if isinstance(__UpperCAmelCase		,						__UpperCAmelCase  ):
  													return not self < other
  							return NotImplemented
  
  
  
  
  	def __hash__(			self			:		Any  )    ->				int:
  							return object.__hash__(self  )
  
  
  
  def  __a  (					)   ->				int:
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCAmelCase_=     0
  						UpperCAmelCase_=     os.path.abspath(os.path.dirname(lowerCAmelCase_       )       )
  						UpperCAmelCase_=     os.path.join(lowerCAmelCase_    ,"""poker_hands.txt"""       )
  						with open(lowerCAmelCase_       ) as file_hand:
  												for line in file_hand:
  																		UpperCAmelCase_=     line[:14].strip()
  																		UpperCAmelCase_=     line[15:].strip()
  																		UpperCAmelCase_,     UpperCAmelCase_=     PokerHand(lowerCAmelCase_       ), PokerHand(lowerCAmelCase_       )
  																		UpperCAmelCase_=     player.compare_with(lowerCAmelCase_       )
  																		if output == "Win":
  																								answer += 1
  						return answer
  
  
  if __name__ == "__main__":
  	solution()
  
  
  
  
  