



from __future__ import annotations

import os





class 		UpperCAmelCase    :
   SCREAMING_SNAKE_CASE__					      =  (
       'High card',
       'One pair',
       'Two pairs',
       'Three of a kind',
       'Straight',
       'Flush',
       'Full house',
       'Four of a kind',
       'Straight flush',
       'Royal flush',
   )

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





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





   @property
   def 						__lowerCAmelCase				(						self      ):
         return self._hand





   def 						__lowerCAmelCase				(						self							,  _lowerCAmelCase      ):
         # 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(__snake_case      )
               else:
                     return "Win" if self._second_pair > other._second_pair else "Loss"
         return "Win" if self._first_pair > other._first_pair else "Loss"





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





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





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





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





   def 						__lowerCAmelCase				(						self      ):
         _lowerCAmelCase			      =	{"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
         _lowerCAmelCase			      =	self._hand.translate(str.maketrans(__snake_case      )      ).split()
         _lowerCAmelCase			      =	[int(card[:-1]      ) for card in new_hand]
         _lowerCAmelCase			      =	{card[-1] for card in new_hand}
         return sorted(__snake_case							,  reverse=__snake_case      ), card_suit





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





   def __str__(						self      ):
         return self._hand





   def __eq__(						self							,  _lowerCAmelCase      ):
         if isinstance(__snake_case							,  __snake_case      ):
               return self.compare_with(__snake_case      ) == "Tie"
         return NotImplemented





   def __lt__(						self							,  _lowerCAmelCase      ):
         if isinstance(__snake_case							,  __snake_case      ):
               return self.compare_with(__snake_case      ) == "Loss"
         return NotImplemented





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





   def __gt__(						self							,  _lowerCAmelCase      ):
         if isinstance(__snake_case							,  __snake_case      ):
               return not self < other and self != other
         return NotImplemented





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





   def __hash__(						self      ):
         return object.__hash__(self      )






def 				UpperCAmelCase__		(					)->List[Any]:
      # Solution for problem number 54 from Project Euler
      # Input from poker_hands.txt file
      _lowerCAmelCase			      =	0
      _lowerCAmelCase			      =	os.path.abspath(os.path.dirname(__lowercase					)					)
      _lowerCAmelCase			      =	os.path.join(__lowercase  ,					'''poker_hands.txt'''					)
      with open(__lowercase					) as file_hand:
            for line in file_hand:
                  _lowerCAmelCase			      =	line[:1_4].strip()
                  _lowerCAmelCase			      =	line[1_5:].strip()
                  _lowerCAmelCase			      =	PokerHand(__lowercase					), PokerHand(__lowercase					)
                  _lowerCAmelCase			      =	player.compare_with(__lowercase					)
                  if output == "Win":
                        answer += 1
      return answer


if __name__ == "__main__":
    solution()



import unittest

import numpy as np

from transformers import ElectraConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
       from transformers.models.electra.modeling_flax_electra import (
           FlaxElectraForCausalLM,
           FlaxElectraForMaskedLM,
           FlaxElectraForMultipleChoice,
           FlaxElectraForPreTraining,
           FlaxElectraForQuestionAnswering,
           FlaxElectraForSequenceClassification,
           FlaxElectraForTokenClassification,
           FlaxElectraModel,
       )





class 			lowerCAmelCase__(     unittest.TestCase    ):






    '''simple docstring'''





    def __init__(						self					: Any							, __snake_case					: Tuple							, __snake_case					: Union[str, Any]=13							, __snake_case					: Tuple=7							, __snake_case					: str=True							, __snake_case					: List[Any]=True							, __snake_case					: Optional[int]=True							, __snake_case					: List[str]=True							, __snake_case					: Tuple=99							, __snake_case					: int=24							, __snake_case					: int=32							, __snake_case					: Tuple=5							, __snake_case					: int=4							, __snake_case					: Any=37							, __snake_case					: int="gelu"							, __snake_case					: Union[str, Any]=0.1							, __snake_case					: Optional[Any]=0.1							, __snake_case					: str=512							, __snake_case					: List[Any]=16							, __snake_case					: Tuple=2							, __snake_case					: List[str]=0.02							, __snake_case					: Any=4							, ):





       '''simple docstring'''
       UpperCAmelCase_				:   Union[str, Any]							= parent
       UpperCAmelCase_				:   Dict							= batch_size
       UpperCAmelCase_				:   Union[str, Any]							= seq_length
       UpperCAmelCase_				:   Any							= is_training
       UpperCAmelCase_				:   Tuple							= use_attention_mask
       UpperCAmelCase_				:   Dict							= use_token_type_ids
       UpperCAmelCase_				:   str							= use_labels
       UpperCAmelCase_				:   Union[str, Any]							= vocab_size
       UpperCAmelCase_				:   Union[str, Any]							= hidden_size
       UpperCAmelCase_				:   Union[str, Any]							= embedding_size
       UpperCAmelCase_				:   Optional[int]							= num_hidden_layers
       UpperCAmelCase_				:   Tuple							= num_attention_heads
       UpperCAmelCase_				:   List[Any]							= intermediate_size
       UpperCAmelCase_				:   Union[str, Any]							= hidden_act
       UpperCAmelCase_				:   Any							= hidden_dropout_prob
       UpperCAmelCase_				:   List[str]							= attention_probs_dropout_prob
       UpperCAmelCase_				:   List[str]							= max_position_embeddings
       UpperCAmelCase_				:   Dict							= type_vocab_size
       UpperCAmelCase_				:   Tuple							= type_sequence_label_size
       UpperCAmelCase_				:   Dict							= initializer_range
       UpperCAmelCase_				:   Any							= num_choices





    def        _lowerCamelCase			(						self					: Optional[int]						):





       '''simple docstring'''
       UpperCAmelCase_				:   Any							= ids_tensor([self.batch_size, self.seq_length]							, self.vocab_size						)

       UpperCAmelCase_				:   Any							= None
       if self.use_attention_mask:
          UpperCAmelCase_				:   List[str]							= random_attention_mask([self.batch_size, self.seq_length]						)

       UpperCAmelCase_				:   List[str]							= None
       if self.use_token_type_ids:
          UpperCAmelCase_				:   str							= ids_tensor([self.batch_size, self.seq_length]							, self.type_vocab_size						)

       UpperCAmelCase_				:   int							= ElectraConfig(
           vocab_size=self.vocab_size							, hidden_size=self.hidden_size							, embedding_size=self.embedding_size							, num_hidden_layers=self.num_hidden_layers							, num_attention_heads=self.num_attention_heads							, intermediate_size=self.intermediate_size							, hidden_act=self.hidden_act							, hidden_dropout_prob=self.hidden_dropout_prob							, attention_probs_dropout_prob=self.attention_probs_dropout_prob							, max_position_embeddings=self.max_position_embeddings							, type_vocab_size=self.type_vocab_size							, initializer_range=self.initializer_range							, )

       return config, input_ids, token_type_ids, attention_mask





    def        _lowerCamelCase			(						self					: int						):





       '''simple docstring'''
       UpperCAmelCase_				:   List[str]							= self.prepare_config_and_inputs()
       UpperCAmelCase_		,   UpperCAmelCase_		,   UpperCAmelCase_		,   UpperCAmelCase_				:   Union[str, Any]							= config_and_inputs
       UpperCAmelCase_				:   Optional[Any]							= {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
       return config, inputs_dict





@require_flax
class 			lowerCAmelCase__(     snake_case__     ,     unittest.TestCase    ):






    '''simple docstring'''





    A_	:  Any								=			True

    A_	:  int								=			(
        (
            FlaxElectraModel,
            FlaxElectraForCausalLM,
            FlaxElectraForMaskedLM,
            FlaxElectraForPreTraining,
            FlaxElectraForTokenClassification,
            FlaxElectraForQuestionAnswering,
            FlaxElectraForMultipleChoice,
            FlaxElectraForSequenceClassification,
        )
        if is_flax_available()
        else ()
    )





    def        _lowerCamelCase			(						self					: Optional[int]						):





       '''simple docstring'''
       UpperCAmelCase_				:   List[str]							= FlaxElectraModelTester(self						)





    @slow
    def        _lowerCamelCase			(						self					: Union[str, Any]						):





       '''simple docstring'''
       for model_class_name in self.all_model_classes:
          if model_class_name == FlaxElectraForMaskedLM:
             UpperCAmelCase_				:   List[str]							= model_class_name.from_pretrained('''google/electra-small-generator'''						)
          else:
             UpperCAmelCase_				:   Optional[Any]							= model_class_name.from_pretrained('''google/electra-small-discriminator'''						)
          UpperCAmelCase_				:   Tuple							= model(np.ones((1, 1)						)						)
          self.assertIsNotNone(__snake_case						)