






"""simple docstring"""





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

import pytest

from .sola import PokerHand

__lowerCamelCase							=  (
    '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)
)

__lowerCamelCase							=  (
    ('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'),
)

__lowerCamelCase							=  (
    ('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),
)

__lowerCamelCase							=  (
    ('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),
)

__lowerCamelCase							=  (
    ('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]),
)

__lowerCamelCase							=  (
    ('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),
)

__lowerCamelCase							=  (
    ('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:
						__magic_name__,			__magic_name__:	Optional[int]							=       randrange(len(__UpperCAmelCase  )  ), randrange(len(__UpperCAmelCase  )  )
						__magic_name__:	Optional[int]							=       ["""Loss""", """Tie""", """Win"""][(play >= oppo) + (play > oppo)]
						__magic_name__,			__magic_name__:	Tuple							=       SORTED_HANDS[play], SORTED_HANDS[oppo]
						return hand, other, expected



def   a    (     __UpperCAmelCase      :    int = 1_0_0  )    ->							Union[str, Any]:
						return (generate_random_hand() for _ in range(__UpperCAmelCase  ))



@pytest.mark.parametrize("""hand, expected"""      ,   __UpperCAmelCase  )
def   a    (     __UpperCAmelCase      :    Dict      ,   __UpperCAmelCase      :    Tuple  )    ->							str:
						assert PokerHand(__UpperCAmelCase  )._is_flush() == expected



@pytest.mark.parametrize("""hand, expected"""      ,   __UpperCAmelCase  )
def   a    (     __UpperCAmelCase      :    int      ,   __UpperCAmelCase      :    Optional[int]  )    ->							Any:
						assert PokerHand(__UpperCAmelCase  )._is_straight() == expected



@pytest.mark.parametrize("""hand, expected, card_values"""      ,   __UpperCAmelCase  )
def   a    (     __UpperCAmelCase      :    Union[str, Any]      ,   __UpperCAmelCase      :    Tuple      ,   __UpperCAmelCase      :    List[Any]  )    ->							Union[str, Any]:
						__magic_name__:	Any							=       PokerHand(__UpperCAmelCase  )
						assert player._is_five_high_straight() == expected
						assert player._card_values == card_values



@pytest.mark.parametrize("""hand, expected"""      ,   __UpperCAmelCase  )
def   a    (     __UpperCAmelCase      :    Optional[int]      ,   __UpperCAmelCase      :    List[str]  )    ->							Optional[Any]:
						assert PokerHand(__UpperCAmelCase  )._is_same_kind() == expected



@pytest.mark.parametrize("""hand, expected"""      ,   __UpperCAmelCase  )
def   a    (     __UpperCAmelCase      :    Union[str, Any]      ,   __UpperCAmelCase      :    Union[str, Any]  )    ->							Dict:
						assert PokerHand(__UpperCAmelCase  )._hand_type == expected



@pytest.mark.parametrize("""hand, other, expected"""      ,   __UpperCAmelCase  )
def   a    (     __UpperCAmelCase      :    List[Any]      ,   __UpperCAmelCase      :    Optional[int]      ,   __UpperCAmelCase      :    Optional[int]  )    ->							List[str]:
						assert PokerHand(__UpperCAmelCase  ).compare_with(PokerHand(__UpperCAmelCase  )  ) == expected



@pytest.mark.parametrize("""hand, other, expected"""      ,   generate_random_hands()  )
def   a    (     __UpperCAmelCase      :    Union[str, Any]      ,   __UpperCAmelCase      :    str      ,   __UpperCAmelCase      :    List[Any]  )    ->							Tuple:
						assert PokerHand(__UpperCAmelCase  ).compare_with(PokerHand(__UpperCAmelCase  )  ) == expected



def   a    (     )    ->							Optional[Any]:
						__magic_name__:	Union[str, Any]							=       [PokerHand(__UpperCAmelCase  ) for hand in SORTED_HANDS]
						__magic_name__:	int							=       poker_hands.copy()
						shuffle(__UpperCAmelCase  )
						__magic_name__:	Dict							=       chain(sorted(__UpperCAmelCase  )  )
						for index, hand in enumerate(__UpperCAmelCase  ):
												assert hand == poker_hands[index]



def   a    (     )    ->							Union[str, Any]:
						# Test that five high straights are compared correctly.
						__magic_name__:	List[Any]							=       [PokerHand("""2D AC 3H 4H 5S"""  ), PokerHand("""2S 3H 4H 5S 6C"""  )]
						pokerhands.sort(reverse=__UpperCAmelCase  )
						assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C"



def   a    (     )    ->							List[Any]:
						# Multiple calls to five_high_straight function should still return True
						# and shouldn't mutate the list in every call other than the first.
						__magic_name__:	Union[str, Any]							=       PokerHand("""2C 4S AS 3D 5C"""  )
						__magic_name__:	int							=       True
						__magic_name__:	Optional[Any]							=       [5, 4, 3, 2, 1_4]
						for _ in range(1_0  ):
												assert pokerhand._is_five_high_straight() == expected
												assert pokerhand._card_values == expected_card_values



def   a    (     )    ->							List[str]:
						# Problem number 54 from Project Euler
						# Testing from poker_hands.txt file
						__magic_name__:	List[str]							=       0
						__magic_name__:	Optional[int]							=       os.path.abspath(os.path.dirname(__UpperCAmelCase  )  )
						__magic_name__:	List[Any]							=       os.path.join(__UpperCAmelCase      ,   """poker_hands.txt"""  )
						with open(__UpperCAmelCase  ) as file_hand:
												for line in file_hand:
																		__magic_name__:	Optional[int]							=       line[:1_4].strip()
																		__magic_name__:	Optional[Any]							=       line[1_5:].strip()
																		__magic_name__,			__magic_name__:	Tuple							=       PokerHand(__UpperCAmelCase  ), PokerHand(__UpperCAmelCase  )
																		__magic_name__:	Any							=       player.compare_with(__UpperCAmelCase  )
																		if output == "Win":
																								answer += 1
						assert answer == 3_7_6











"""simple docstring"""





import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers.models.esm.modeling_esmfold import EsmForProteinFolding



class       __A		:

					def __init__(			self  :      str     ,		__snake_case  :      int     ,		__snake_case  :      Dict=1_3     ,		__snake_case  :      Dict=7     ,		__snake_case  :      str=False     ,		__snake_case  :      Dict=True     ,		__snake_case  :      Tuple=False     ,		__snake_case  :      List[Any]=False     ,		__snake_case  :      Dict=1_9     ,		__snake_case  :      Dict=3_2     ,		__snake_case  :      Union[str, Any]=5     ,		__snake_case  :      List[Any]=4     ,		__snake_case  :      List[Any]=3_7     ,		__snake_case  :      Union[str, Any]="gelu"     ,		__snake_case  :      List[str]=0.1     ,		__snake_case  :      Union[str, Any]=0.1     ,		__snake_case  :      List[str]=5_1_2     ,		__snake_case  :      List[str]=1_6     ,		__snake_case  :      Tuple=2     ,		__snake_case  :      Optional[Any]=0.02     ,		__snake_case  :      str=3     ,		__snake_case  :      List[str]=4     ,		__snake_case  :      Optional[int]=None     ,		)			->							Optional[int]:
											__magic_name__:	Any							=       parent
											__magic_name__:	Optional[Any]							=       batch_size
											__magic_name__:	Optional[Any]							=       seq_length
											__magic_name__:	Optional[Any]							=       is_training
											__magic_name__:	str							=       use_input_mask
											__magic_name__:	Optional[Any]							=       use_token_type_ids
											__magic_name__:	List[str]							=       use_labels
											__magic_name__:	List[str]							=       vocab_size
											__magic_name__:	Union[str, Any]							=       hidden_size
											__magic_name__:	List[Any]							=       num_hidden_layers
											__magic_name__:	Dict							=       num_attention_heads
											__magic_name__:	int							=       intermediate_size
											__magic_name__:	List[Any]							=       hidden_act
											__magic_name__:	int							=       hidden_dropout_prob
											__magic_name__:	List[str]							=       attention_probs_dropout_prob
											__magic_name__:	Tuple							=       max_position_embeddings
											__magic_name__:	Any							=       type_vocab_size
											__magic_name__:	Union[str, Any]							=       type_sequence_label_size
											__magic_name__:	List[str]							=       initializer_range
											__magic_name__:	Optional[Any]							=       num_labels
											__magic_name__:	List[str]							=       num_choices
											__magic_name__:	Tuple							=       scope

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Any:
											__magic_name__:	Union[str, Any]							=       ids_tensor([self.batch_size, self.seq_length]     ,		self.vocab_size					)

											__magic_name__:	Dict							=       None
											if self.use_input_mask:
																	__magic_name__:	Optional[int]							=       random_attention_mask([self.batch_size, self.seq_length]					)

											__magic_name__:	str							=       None
											__magic_name__:	Optional[Any]							=       None
											__magic_name__:	int							=       None
											if self.use_labels:
																	__magic_name__:	List[Any]							=       ids_tensor([self.batch_size]     ,		self.type_sequence_label_size					)
																	__magic_name__:	str							=       ids_tensor([self.batch_size, self.seq_length]     ,		self.num_labels					)
																	__magic_name__:	Dict							=       ids_tensor([self.batch_size]     ,		self.num_choices					)

											__magic_name__:	Dict							=       self.get_config()

											return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels

					def   lowerCamelCase__   (			self  :      int					)			->							Any:
											__magic_name__:	List[Any]							=       EsmConfig(
											    vocab_size=3_3     ,		hidden_size=self.hidden_size     ,		pad_token_id=1     ,		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     ,		is_folding_model=__snake_case     ,		esmfold_config={"""trunk""": {"""num_blocks""": 2}, """fp16_esm""": False}     ,		)
											return config

					def   lowerCamelCase__   (			self  :      Optional[int]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Any     ,		__snake_case  :      List[Any]     ,		__snake_case  :      Any     ,		__snake_case  :      Union[str, Any]					)			->							Optional[Any]:
											__magic_name__:	str							=       EsmForProteinFolding(config=__snake_case					).float()
											model.to(__snake_case					)
											model.eval()
											__magic_name__:	str							=       model(__snake_case     ,		attention_mask=__snake_case					)
											__magic_name__:	Any							=       model(__snake_case					)
											__magic_name__:	Dict							=       model(__snake_case					)

											self.parent.assertEqual(result.positions.shape     ,		(8, self.batch_size, self.seq_length, 1_4, 3)					)
											self.parent.assertEqual(result.angles.shape     ,		(8, self.batch_size, self.seq_length, 7, 2)					)






					def   lowerCamelCase__   (			self  :      Any					)			->							int:
											__magic_name__:	str							=       self.prepare_config_and_inputs()
											(
											    (
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			
											):	Union[str, Any]							=       config_and_inputs
											__magic_name__:	Any							=       {"""input_ids""": input_ids, """attention_mask""": input_mask}
											return config, inputs_dict



@require_torch
class       __A		(   SCREAMING_SNAKE_CASE_     ,SCREAMING_SNAKE_CASE_     ,unittest.TestCase			):
					UpperCAmelCase__								=				False

					UpperCAmelCase__								=				(EsmForProteinFolding,) if is_torch_available() else ()
					UpperCAmelCase__								=				()
					UpperCAmelCase__								=				{} if is_torch_available() else {}
					UpperCAmelCase__								=				False

					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Optional[Any]:
											__magic_name__:	Optional[int]							=       EsmFoldModelTester(self					)
											__magic_name__:	Optional[Any]							=       ConfigTester(self     ,		config_class=__snake_case     ,		hidden_size=3_7					)

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Any:
											self.config_tester.run_common_tests()

					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											__magic_name__:	Tuple							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__snake_case					)

					@unittest.skip("""Does not support attention outputs"""					)
					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											pass

					@unittest.skip
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Tuple:
											pass

					@unittest.skip("""Esm does not support embedding resizing"""					)
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Optional[int]:
											pass

					@unittest.skip("""Esm does not support embedding resizing"""					)
					def   lowerCamelCase__   (			self  :      str					)			->							str:
											pass

					@unittest.skip("""ESMFold does not support passing input embeds!"""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							List[str]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Tuple:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold does not output hidden states in the normal way."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMfold does not output hidden states in the normal way."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							int:
											pass

					@unittest.skip("""ESMFold only has one output format."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							str:
											pass

					@unittest.skip("""This test doesn't work for ESMFold and doesn't test core functionality"""					)
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Dict:
											pass

					@unittest.skip("""ESMFold does not support input chunking."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Any:
											pass

					@unittest.skip("""ESMFold doesn't respect you and it certainly doesn't respect your initialization arguments."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Union[str, Any]:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							int:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[str]:
											pass

					@unittest.skip("""ESMFold doesn't support data parallel."""					)
					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											pass






					@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							Dict:
											pass



@require_torch
class       __A		(   SCREAMING_SNAKE_CASE_			):

					@slow
					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							List[Any]:
											__magic_name__:	Any							=       EsmForProteinFolding.from_pretrained("""facebook/esmfold_v1"""					).float()
											model.eval()
											__magic_name__:	Optional[int]							=       torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]					)
											__magic_name__:	Dict							=       model(__snake_case					)["""positions"""]
											__magic_name__:	Tuple							=       torch.tensor([2.5828, 0.7993, -10.9334]     ,		dtype=torch.floataa					)
											self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]     ,		__snake_case     ,		atol=1E-4					)					)



