



from __future__ import annotations

import os


class 	a__       :


					"""simple docstring"""



					A__  :				Optional[int]					 =				(
					    '''High card''',
					    '''One pair''',
					    '''Two pairs''',
					    '''Three of a kind''',
					    '''Straight''',
					    '''Flush''',
					    '''Full house''',
					    '''Four of a kind''',
					    '''Straight flush''',
					    '''Royal flush''',
					)

					A__  :				str					 =				(
					    '''''',  # placeholder as tuples are zero-indexed
					    '''One''',
					    '''Two''',
					    '''Three''',
					    '''Four''',
					    '''Five''',
					    '''Six''',
					    '''Seven''',
					    '''Eight''',
					    '''Nine''',
					    '''Ten''',
					    '''Jack''',
					    '''Queen''',
					    '''King''',
					    '''Ace''',
					)

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

					@property
					def 				__UpperCAmelCase		(		self     :Any    ):
										return self._hand

					def 				__UpperCAmelCase		(		self     :int      ,  lowercase__     :PokerHand    ):
										# 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(_lowerCAmelCase    )
															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						   =       PokerHand._HAND_NAME[self._hand_type - 14]
										lowercase						   =       PokerHand._CARD_NAME[self._high_card]
										lowercase						   =       PokerHand._CARD_NAME[self._first_pair]
										lowercase						   =       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]:
															lowercase						   =       '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 				__UpperCAmelCase		(		self     :Any      ,  lowercase__     :PokerHand    ):
										# 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 				__UpperCAmelCase		(		self     :Optional[Any]    ):
										# 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 				__UpperCAmelCase		(		self     :Any    ):
										return len(self._card_suit    ) == 1

					def 				__UpperCAmelCase		(		self     :str    ):
										# 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
																				lowercase						   =       self._card_values.pop(0    )
																				self._card_values.append(_lowerCAmelCase    )
															return True
										return False

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

					def 				__UpperCAmelCase		(		self     :Dict    ):
										# 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
										lowercase						   =       lowercase						   =       lowercase						   =       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						   =       self._card_values[i]
																									kind += 1
																				elif vala == self._card_values[i]:
																									kind += 2
																				elif not vala:
																									lowercase						   =       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						   =       kind + 2 if kind in [4, 5] else kind
										# first meaning first pair to compare in 'compare_with'
										lowercase						   =       max(_lowerCAmelCase      ,  _lowerCAmelCase    )
										lowercase						   =       min(_lowerCAmelCase      ,  _lowerCAmelCase    )
										# 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(_lowerCAmelCase    ) != 3:
															lowercase   ,      lowercase						   =       second, first
										lowercase						   =       first
										lowercase						   =       second
										return kind

					def 				__UpperCAmelCase		(		self     :Optional[int]    ):
										# Internal representation of hand as a list of card values and
										# a set of card suit
										lowercase						   =       {'T': '10', 'J': '11', 'Q': '12', 'K': '13', 'A': '14'}
										lowercase						   =       self._hand.translate(str.maketrans(_lowerCAmelCase    )    ).split()
										lowercase						   =       [int(card[:-1]    ) for card in new_hand]
										lowercase						   =       {card[-1] for card in new_hand}
										return sorted(_lowerCAmelCase      ,  reverse=_lowerCAmelCase    ), card_suit

					def __repr__(		self     :Tuple    ):
										return F"""{self.__class__}(\"{self._hand}\")"""

					def __str__(		self     :Optional[int]    ):
										return self._hand

					def __eq__(		self     :Optional[int]      ,  lowercase__     :str    ):
										if isinstance(_lowerCAmelCase      ,  _lowerCAmelCase    ):
															return self.compare_with(_lowerCAmelCase    ) == "Tie"
										return NotImplemented

					def __lt__(		self     :List[Any]      ,  lowercase__     :int    ):
										if isinstance(_lowerCAmelCase      ,  _lowerCAmelCase    ):
															return self.compare_with(_lowerCAmelCase    ) == "Loss"
										return NotImplemented

					def __le__(		self     :str      ,  lowercase__     :Dict    ):
										if isinstance(_lowerCAmelCase      ,  _lowerCAmelCase    ):
															return self < other or self == other
										return NotImplemented

					def __gt__(		self     :Union[str, Any]      ,  lowercase__     :List[Any]    ):
										if isinstance(_lowerCAmelCase      ,  _lowerCAmelCase    ):
															return not self < other and self != other
										return NotImplemented

					def __ge__(		self     :Dict      ,  lowercase__     :Dict    ):
										if isinstance(_lowerCAmelCase      ,  _lowerCAmelCase    ):
															return not self < other
										return NotImplemented



					def __hash__(		self     :Optional[int]    ):
										return object.__hash__(self    )





def 		__snake_case						(    ):
					"""simple docstring"""






					lowercase						   =       0
					lowercase						   =       os.path.abspath(os.path.dirname(__SCREAMING_SNAKE_CASE				)				)
					lowercase						   =       os.path.join(__SCREAMING_SNAKE_CASE       ,			'poker_hands.txt'				)
					with open(__SCREAMING_SNAKE_CASE				) as file_hand:
										for line in file_hand:
															lowercase						   =       line[:14].strip()
															lowercase						   =       line[15:].strip()
															lowercase   ,      lowercase						   =       PokerHand(__SCREAMING_SNAKE_CASE				), PokerHand(__SCREAMING_SNAKE_CASE				)
															lowercase						   =       player.compare_with(__SCREAMING_SNAKE_CASE				)
															if output == "Win":
																				answer += 1
					return answer


if __name__ == "__main__":
		solution()








import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
       from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


_UpperCamelCase:					str     =get_tests_dir('fixtures/test_sentencepiece.model')





@require_torch
@require_torchaudio
@require_sentencepiece
class 						__lowercase(     unittest.TestCase   ):


       """simple docstring"""







       def SCREAMING_SNAKE_CASE_				(     self					:			List[str]       )					->   Any:
         _lowerCAmelCase						=		tempfile.mkdtemp()

         _lowerCAmelCase						=		['<s>', '<pad>', '</s>', '<unk>', '▁This', '▁is', '▁a', '▁t', 'est']
         _lowerCAmelCase						=		dict(zip(_lowerCAmelCase  ,      range(len(_lowerCAmelCase       )       )       )       )
         _lowerCAmelCase						=		Path(self.tmpdirname       )
         save_json(_lowerCAmelCase  ,      save_dir / VOCAB_FILES_NAMES['vocab_file']       )
         if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
           copyfile(_lowerCAmelCase  ,      save_dir / VOCAB_FILES_NAMES['spm_file']       )

         _lowerCAmelCase						=		SpeechaTextTokenizer.from_pretrained(self.tmpdirname       )
         tokenizer.save_pretrained(self.tmpdirname       )

         _lowerCAmelCase						=		{
             'feature_size': 24,
             'num_mel_bins': 24,
             'padding_value': 0.0,
             'sampling_rate': 1_6000,
             'return_attention_mask': False,
             'do_normalize': True,
         }
         save_json(_lowerCAmelCase  ,      save_dir / FEATURE_EXTRACTOR_NAME       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Union[str, Any]  ,      **_lowerCAmelCase					:			Optional[Any]       )					->   List[str]:
         return SpeechaTextTokenizer.from_pretrained(self.tmpdirname  ,      **_lowerCAmelCase       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]  ,      **_lowerCAmelCase					:			Dict       )					->   Tuple:
         return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname  ,      **_lowerCAmelCase       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]       )					->   int:
         shutil.rmtree(self.tmpdirname       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[int]       )					->   Any:
         _lowerCAmelCase						=		self.get_tokenizer()
         _lowerCAmelCase						=		self.get_feature_extractor()

         _lowerCAmelCase						=		SpeechaTextProcessor(tokenizer=_lowerCAmelCase  ,      feature_extractor=_lowerCAmelCase       )

         processor.save_pretrained(self.tmpdirname       )
         _lowerCAmelCase						=		SpeechaTextProcessor.from_pretrained(self.tmpdirname       )

         self.assertEqual(processor.tokenizer.get_vocab()  ,      tokenizer.get_vocab()       )
         self.assertIsInstance(processor.tokenizer  ,      _lowerCAmelCase       )

         self.assertEqual(processor.feature_extractor.to_json_string()  ,      feature_extractor.to_json_string()       )
         self.assertIsInstance(processor.feature_extractor  ,      _lowerCAmelCase       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[int]       )					->   int:
         _lowerCAmelCase						=		SpeechaTextProcessor(
             tokenizer=self.get_tokenizer()  ,      feature_extractor=self.get_feature_extractor()       )
         processor.save_pretrained(self.tmpdirname       )

         _lowerCAmelCase						=		self.get_tokenizer(bos_token='(BOS)'  ,      eos_token='(EOS)'       )
         _lowerCAmelCase						=		self.get_feature_extractor(do_normalize=_lowerCAmelCase  ,      padding_value=1.0       )

         _lowerCAmelCase						=		SpeechaTextProcessor.from_pretrained(
             self.tmpdirname  ,      bos_token='(BOS)'  ,      eos_token='(EOS)'  ,      do_normalize=_lowerCAmelCase  ,      padding_value=1.0       )

         self.assertEqual(processor.tokenizer.get_vocab()  ,      tokenizer_add_kwargs.get_vocab()       )
         self.assertIsInstance(processor.tokenizer  ,      _lowerCAmelCase       )

         self.assertEqual(processor.feature_extractor.to_json_string()  ,      feature_extractor_add_kwargs.to_json_string()       )
         self.assertIsInstance(processor.feature_extractor  ,      _lowerCAmelCase       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Dict       )					->   Union[str, Any]:
         _lowerCAmelCase						=		self.get_feature_extractor()
         _lowerCAmelCase						=		self.get_tokenizer()

         _lowerCAmelCase						=		SpeechaTextProcessor(tokenizer=_lowerCAmelCase  ,      feature_extractor=_lowerCAmelCase       )

         _lowerCAmelCase						=		floats_list((3, 1000)       )

         _lowerCAmelCase						=		feature_extractor(_lowerCAmelCase  ,      return_tensors='np'       )
         _lowerCAmelCase						=		processor(_lowerCAmelCase  ,      return_tensors='np'       )

         for key in input_feat_extract.keys():
           self.assertAlmostEqual(input_feat_extract[key].sum()  ,      input_processor[key].sum()  ,      delta=1e-2       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Dict       )					->   Any:
         _lowerCAmelCase						=		self.get_feature_extractor()
         _lowerCAmelCase						=		self.get_tokenizer()

         _lowerCAmelCase						=		SpeechaTextProcessor(tokenizer=_lowerCAmelCase  ,      feature_extractor=_lowerCAmelCase       )

         _lowerCAmelCase						=		'This is a test string'

         _lowerCAmelCase						=		processor(text=_lowerCAmelCase       )

         _lowerCAmelCase						=		tokenizer(_lowerCAmelCase       )

         for key in encoded_tok.keys():
           self.assertListEqual(encoded_tok[key]  ,      encoded_processor[key]       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Tuple       )					->   Tuple:
         _lowerCAmelCase						=		self.get_feature_extractor()
         _lowerCAmelCase						=		self.get_tokenizer()

         _lowerCAmelCase						=		SpeechaTextProcessor(tokenizer=_lowerCAmelCase  ,      feature_extractor=_lowerCAmelCase       )

         _lowerCAmelCase						=		[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

         _lowerCAmelCase						=		processor.batch_decode(_lowerCAmelCase       )
         _lowerCAmelCase						=		tokenizer.batch_decode(_lowerCAmelCase       )

         self.assertListEqual(_lowerCAmelCase  ,      _lowerCAmelCase       )






       def SCREAMING_SNAKE_CASE_				(     self					:			Any       )					->   Union[str, Any]:
         _lowerCAmelCase						=		self.get_feature_extractor()
         _lowerCAmelCase						=		self.get_tokenizer()

         _lowerCAmelCase						=		SpeechaTextProcessor(tokenizer=_lowerCAmelCase  ,      feature_extractor=_lowerCAmelCase       )

         self.assertListEqual(
             processor.model_input_names  ,      feature_extractor.model_input_names  ,      msg='`processor` and `feature_extractor` model input names do not match'  ,      )
