



import os
from itertools import chain
from random import randrange, shuffle

import pytest

from .sola import PokerHand

__A							       =		(
    '''4S 3H 2C 7S 5H''',
    '''9D 8H 2C 6S 7H''',
    '''2D 6D 9D TH 7D''',
    '''TC 8C 2S JH 6C''',
    '''JH 8S TH AH QH''',
    '''TS KS 5S 9S AC''',
    '''KD 6S 9D TH AD''',
    '''KS 8D 4D 9S 4S''',  # pair
    '''8C 4S KH JS 4D''',  # pair
    '''QH 8H KD JH 8S''',  # pair
    '''KC 4H KS 2H 8D''',  # pair
    '''KD 4S KC 3H 8S''',  # pair
    '''AH 8S AS KC JH''',  # pair
    '''3H 4C 4H 3S 2H''',  # 2 pairs
    '''5S 5D 2C KH KH''',  # 2 pairs
    '''3C KH 5D 5S KH''',  # 2 pairs
    '''AS 3C KH AD KH''',  # 2 pairs
    '''7C 7S 3S 7H 5S''',  # 3 of a kind
    '''7C 7S KH 2H 7H''',  # 3 of a kind
    '''AC KH QH AH AS''',  # 3 of a kind
    '''2H 4D 3C AS 5S''',  # straight (low ace)
    '''3C 5C 4C 2C 6H''',  # straight
    '''6S 8S 7S 5H 9H''',  # straight
    '''JS QS 9H TS KH''',  # straight
    '''QC KH TS JS AH''',  # straight (high ace)
    '''8C 9C 5C 3C TC''',  # flush
    '''3S 8S 9S 5S KS''',  # flush
    '''4C 5C 9C 8C KC''',  # flush
    '''JH 8H AH KH QH''',  # flush
    '''3D 2H 3H 2C 2D''',  # full house
    '''2H 2C 3S 3H 3D''',  # full house
    '''KH KC 3S 3H 3D''',  # full house
    '''JC 6H JS JD JH''',  # 4 of a kind
    '''JC 7H JS JD JH''',  # 4 of a kind
    '''JC KH JS JD JH''',  # 4 of a kind
    '''2S AS 4S 5S 3S''',  # straight flush (low ace)
    '''2D 6D 3D 4D 5D''',  # straight flush
    '''5C 6C 3C 7C 4C''',  # straight flush
    '''JH 9H TH KH QH''',  # straight flush
    '''JH AH TH KH QH''',  # royal flush (high ace straight flush)
)

__A							       =		(
    ('''2H 3H 4H 5H 6H''', '''KS AS TS QS JS''', '''Loss'''),
    ('''2H 3H 4H 5H 6H''', '''AS AD AC AH JD''', '''Win'''),
    ('''AS AH 2H AD AC''', '''JS JD JC JH 3D''', '''Win'''),
    ('''2S AH 2H AS AC''', '''JS JD JC JH AD''', '''Loss'''),
    ('''2S AH 2H AS AC''', '''2H 3H 5H 6H 7H''', '''Win'''),
    ('''AS 3S 4S 8S 2S''', '''2H 3H 5H 6H 7H''', '''Win'''),
    ('''2H 3H 5H 6H 7H''', '''2S 3H 4H 5S 6C''', '''Win'''),
    ('''2S 3H 4H 5S 6C''', '''3D 4C 5H 6H 2S''', '''Tie'''),
    ('''2S 3H 4H 5S 6C''', '''AH AC 5H 6H AS''', '''Win'''),
    ('''2S 2H 4H 5S 4C''', '''AH AC 5H 6H AS''', '''Loss'''),
    ('''2S 2H 4H 5S 4C''', '''AH AC 5H 6H 7S''', '''Win'''),
    ('''6S AD 7H 4S AS''', '''AH AC 5H 6H 7S''', '''Loss'''),
    ('''2S AH 4H 5S KC''', '''AH AC 5H 6H 7S''', '''Loss'''),
    ('''2S 3H 6H 7S 9C''', '''7H 3C TH 6H 9S''', '''Loss'''),
    ('''4S 5H 6H TS AC''', '''3S 5H 6H TS AC''', '''Win'''),
    ('''2S AH 4H 5S 6C''', '''AD 4C 5H 6H 2C''', '''Tie'''),
    ('''AS AH 3H AD AC''', '''AS AH 2H AD AC''', '''Win'''),
    ('''AH AC 5H 5C QS''', '''AH AC 5H 5C KS''', '''Loss'''),
    ('''AH AC 5H 5C QS''', '''KH KC 5H 5C QS''', '''Win'''),
    ('''7C 7S KH 2H 7H''', '''3C 3S AH 2H 3H''', '''Win'''),
    ('''3C 3S AH 2H 3H''', '''7C 7S KH 2H 7H''', '''Loss'''),
    ('''6H 5H 4H 3H 2H''', '''5H 4H 3H 2H AH''', '''Win'''),
    ('''5H 4H 3H 2H AH''', '''5H 4H 3H 2H AH''', '''Tie'''),
    ('''5H 4H 3H 2H AH''', '''6H 5H 4H 3H 2H''', '''Loss'''),
    ('''AH AD KS KC AC''', '''AH KD KH AC KC''', '''Win'''),
    ('''2H 4D 3C AS 5S''', '''2H 4D 3C 6S 5S''', '''Loss'''),
    ('''2H 3S 3C 3H 2S''', '''3S 3C 2S 2H 2D''', '''Win'''),
    ('''4D 6D 5D 2D JH''', '''3S 8S 3H TC KH''', '''Loss'''),
    ('''4S 6C 8S 3S 7S''', '''AD KS 2D 7D 7C''', '''Loss'''),
    ('''6S 4C 7H 8C 3H''', '''5H JC AH 9D 9C''', '''Loss'''),
    ('''9D 9H JH TC QH''', '''3C 2S JS 5C 7H''', '''Win'''),
    ('''2H TC 8S AD 9S''', '''4H TS 7H 2C 5C''', '''Win'''),
    ('''9D 3S 2C 7S 7C''', '''JC TD 3C TC 9H''', '''Loss'''),
)

__A							       =		(
    ('''2H 3H 4H 5H 6H''', True),
    ('''AS AH 2H AD AC''', False),
    ('''2H 3H 5H 6H 7H''', True),
    ('''KS AS TS QS JS''', True),
    ('''8H 9H QS JS TH''', False),
    ('''AS 3S 4S 8S 2S''', True),
)

__A							       =		(
    ('''2H 3H 4H 5H 6H''', True),
    ('''AS AH 2H AD AC''', False),
    ('''2H 3H 5H 6H 7H''', False),
    ('''KS AS TS QS JS''', True),
    ('''8H 9H QS JS TH''', True),
)

__A							       =		(
    ('''2H 4D 3C AS 5S''', True, [5, 4, 3, 2, 14]),
    ('''2H 5D 3C AS 5S''', False, [14, 5, 5, 3, 2]),
    ('''JH QD KC AS TS''', False, [14, 13, 12, 11, 10]),
    ('''9D 3S 2C 7S 7C''', False, [9, 7, 7, 3, 2]),
)

__A							       =		(
    ('''JH AH TH KH QH''', 0),
    ('''JH 9H TH KH QH''', 0),
    ('''JC KH JS JD JH''', 7),
    ('''KH KC 3S 3H 3D''', 6),
    ('''8C 9C 5C 3C TC''', 0),
    ('''JS QS 9H TS KH''', 0),
    ('''7C 7S KH 2H 7H''', 3),
    ('''3C KH 5D 5S KH''', 2),
    ('''QH 8H KD JH 8S''', 1),
    ('''2D 6D 9D TH 7D''', 0),
)

__A							       =		(
    ('''JH AH TH KH QH''', 23),
    ('''JH 9H TH KH QH''', 22),
    ('''JC KH JS JD JH''', 21),
    ('''KH KC 3S 3H 3D''', 20),
    ('''8C 9C 5C 3C TC''', 19),
    ('''JS QS 9H TS KH''', 18),
    ('''7C 7S KH 2H 7H''', 17),
    ('''3C KH 5D 5S KH''', 16),
    ('''QH 8H KD JH 8S''', 15),
    ('''2D 6D 9D TH 7D''', 14),
)



def 			__a	(       ) ->					Any:






						'''simple docstring'''



						UpperCAmelCase_,  UpperCAmelCase_=  randrange(len(__A							)							), randrange(len(__A							)							)
						UpperCAmelCase_=  ["""Loss""", """Tie""", """Win"""][(play >= oppo) + (play > oppo)]
						UpperCAmelCase_,  UpperCAmelCase_=  SORTED_HANDS[play], SORTED_HANDS[oppo]
						return hand, other, expected



def 			__a	(       lowerCAmelCase_  :   Optional[int] = 1_00							) ->					Optional[int]:






						'''simple docstring'''



						return (generate_random_hand() for _ in range(__A							))



@pytest.mark.parametrize("""hand, expected"""     ,__A							)
def 			__a	(       lowerCAmelCase_  :   Tuple     ,lowerCAmelCase_  :   str							) ->					int:






						'''simple docstring'''



						assert PokerHand(__A							)._is_flush() == expected



@pytest.mark.parametrize("""hand, expected"""     ,__A							)
def 			__a	(       lowerCAmelCase_  :   Optional[int]     ,lowerCAmelCase_  :   Any							) ->					Tuple:






						'''simple docstring'''



						assert PokerHand(__A							)._is_straight() == expected



@pytest.mark.parametrize("""hand, expected, card_values"""     ,__A							)
def 			__a	(       lowerCAmelCase_  :   Any     ,lowerCAmelCase_  :   int     ,lowerCAmelCase_  :   str							) ->					List[str]:






						'''simple docstring'''



						UpperCAmelCase_=  PokerHand(__A							)
						assert player._is_five_high_straight() == expected
						assert player._card_values == card_values



@pytest.mark.parametrize("""hand, expected"""     ,__A							)
def 			__a	(       lowerCAmelCase_  :   str     ,lowerCAmelCase_  :   Optional[Any]							) ->					Dict:






						'''simple docstring'''



						assert PokerHand(__A							)._is_same_kind() == expected



@pytest.mark.parametrize("""hand, expected"""     ,__A							)
def 			__a	(       lowerCAmelCase_  :   List[Any]     ,lowerCAmelCase_  :   Union[str, Any]							) ->					List[Any]:






						'''simple docstring'''



						assert PokerHand(__A							)._hand_type == expected



@pytest.mark.parametrize("""hand, other, expected"""     ,__A							)
def 			__a	(       lowerCAmelCase_  :   Dict     ,lowerCAmelCase_  :   Dict     ,lowerCAmelCase_  :   List[Any]							) ->					Optional[Any]:






						'''simple docstring'''



						assert PokerHand(__A							).compare_with(PokerHand(__A							)							) == expected



@pytest.mark.parametrize("""hand, other, expected"""     ,generate_random_hands()							)
def 			__a	(       lowerCAmelCase_  :   Optional[int]     ,lowerCAmelCase_  :   Optional[Any]     ,lowerCAmelCase_  :   List[str]							) ->					Any:






						'''simple docstring'''



						assert PokerHand(__A							).compare_with(PokerHand(__A							)							) == expected



def 			__a	(       ) ->					Tuple:






						'''simple docstring'''



						UpperCAmelCase_=  [PokerHand(__A							) for hand in SORTED_HANDS]
						UpperCAmelCase_=  poker_hands.copy()
						shuffle(__A							)
						UpperCAmelCase_=  chain(sorted(__A							)							)
						for index, hand in enumerate(__A							):
												assert hand == poker_hands[index]



def 			__a	(       ) ->					str:






						'''simple docstring'''



						UpperCAmelCase_=  [PokerHand("""2D AC 3H 4H 5S"""							), PokerHand("""2S 3H 4H 5S 6C"""							)]
						pokerhands.sort(reverse=__A							)
						assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C"



def 			__a	(       ) ->					Optional[int]:






						'''simple docstring'''



						UpperCAmelCase_=  PokerHand("""2C 4S AS 3D 5C"""							)
						UpperCAmelCase_=  True
						UpperCAmelCase_=  [5, 4, 3, 2, 14]
						for _ in range(10							):
												assert pokerhand._is_five_high_straight() == expected
												assert pokerhand._card_values == expected_card_values



def 			__a	(       ) ->					Optional[int]:






						'''simple docstring'''



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









'''simple docstring'''





import unittest

import numpy as np

from transformers import AlbertConfig, 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():
  import jax.numpy as jnp

  from transformers.models.albert.modeling_flax_albert import (
      FlaxAlbertForMaskedLM,
      FlaxAlbertForMultipleChoice,
      FlaxAlbertForPreTraining,
      FlaxAlbertForQuestionAnswering,
      FlaxAlbertForSequenceClassification,
      FlaxAlbertForTokenClassification,
      FlaxAlbertModel,
  )






class __A     (    unittest.TestCase		):



 '''simple docstring'''







 def __init__(self					,  A					,  A=13					,  A=7					,  A=True					,  A=True					,  A=True					,  A=True					,  A=99					,  A=32					,  A=5					,  A=4					,  A=37					,  A="gelu"					,  A=0.1					,  A=0.1					,  A=512					,  A=16					,  A=2					,  A=0.02					,  A=4					,  )       ->	List[str]:


      """simple docstring"""



      _a           =    parent
      _a           =    batch_size
      _a           =    seq_length
      _a           =    is_training
      _a           =    use_attention_mask
      _a           =    use_token_type_ids
      _a           =    use_labels
      _a           =    vocab_size
      _a           =    hidden_size
      _a           =    num_hidden_layers
      _a           =    num_attention_heads
      _a           =    intermediate_size
      _a           =    hidden_act
      _a           =    hidden_dropout_prob
      _a           =    attention_probs_dropout_prob
      _a           =    max_position_embeddings
      _a           =    type_vocab_size
      _a           =    type_sequence_label_size
      _a           =    initializer_range
      _a           =    num_choices



 def    a__    (self			)       ->	str:


      """simple docstring"""



      _a           =    ids_tensor([self.batch_size, self.seq_length]					,  self.vocab_size			)

      _a           =    None
      if self.use_attention_mask:
           _a           =    random_attention_mask([self.batch_size, self.seq_length]			)

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

      _a           =    AlbertConfig(
          vocab_size=self.vocab_size					,  hidden_size=self.hidden_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					,  is_decoder=A					,  initializer_range=self.initializer_range					,  )

      return config, input_ids, token_type_ids, attention_mask



 def    a__    (self			)       ->	List[str]:


      """simple docstring"""



      _a           =    self.prepare_config_and_inputs()
      _a    ,       _a    ,       _a    ,       _a           =    config_and_inputs
      _a           =    {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
      return config, inputs_dict






@require_flax
class __A     (    A  ,  unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase       :			Optional[int]		=			(
     (
         FlaxAlbertModel,
         FlaxAlbertForPreTraining,
         FlaxAlbertForMaskedLM,
         FlaxAlbertForMultipleChoice,
         FlaxAlbertForQuestionAnswering,
         FlaxAlbertForSequenceClassification,
         FlaxAlbertForTokenClassification,
         FlaxAlbertForQuestionAnswering,
     )
     if is_flax_available()
     else ()
 )



 def    a__    (self			)       ->	Union[str, Any]:


      """simple docstring"""



      _a           =    FlaxAlbertModelTester(self			)



 @slow
 def    a__    (self			)       ->	str:


      """simple docstring"""



      for model_class_name in self.all_model_classes:
           _a           =    model_class_name.from_pretrained('''albert-base-v2'''			)
           _a           =    model(np.ones((1, 1)			)			)
           self.assertIsNotNone(A			)






@require_flax
class __A     (    unittest.TestCase		):



 '''simple docstring'''







 @slow
 def    a__    (self			)       ->	Dict:


      """simple docstring"""



      _a           =    FlaxAlbertModel.from_pretrained('''albert-base-v2'''			)
      _a           =    np.array([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]			)
      _a           =    np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]			)
      _a           =    model(A					,  attention_mask=A			)[0]
      _a           =    (1, 11, 768)
      self.assertEqual(output.shape					,  A			)
      _a           =    np.array(
          [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]]			)

      self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]					,  A					,  atol=1E-4			)			)



