



import unittest

from transformers import YosoConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
	import torch

	from transformers import (
	    YosoForMaskedLM,
	    YosoForMultipleChoice,
	    YosoForQuestionAnswering,
	    YosoForSequenceClassification,
	    YosoForTokenClassification,
	    YosoModel,
	)
	from transformers.models.yoso.modeling_yoso import YOSO_PRETRAINED_MODEL_ARCHIVE_LIST






class 	lowercase		:






	"""simple docstring"""


	def __init__(			self			:		int		,						__UpperCAmelCase			:		int		,						__UpperCAmelCase			:		Optional[int]=13		,						__UpperCAmelCase			:		Optional[Any]=7		,						__UpperCAmelCase			:		Union[str, Any]=True		,						__UpperCAmelCase			:		Dict=True		,						__UpperCAmelCase			:		int=True		,						__UpperCAmelCase			:		Optional[int]=True		,						__UpperCAmelCase			:		Optional[Any]=99		,						__UpperCAmelCase			:		List[Any]=32		,						__UpperCAmelCase			:		int=5		,						__UpperCAmelCase			:		List[str]=4		,						__UpperCAmelCase			:		Union[str, Any]=37		,						__UpperCAmelCase			:		Any="gelu"		,						__UpperCAmelCase			:		Any=0.1		,						__UpperCAmelCase			:		List[Any]=0.1		,						__UpperCAmelCase			:		Any=512		,						__UpperCAmelCase			:		Tuple=16		,						__UpperCAmelCase			:		Any=2		,						__UpperCAmelCase			:		Tuple=0.02		,						__UpperCAmelCase			:		Any=3		,						__UpperCAmelCase			:		Tuple=4		,						__UpperCAmelCase			:		int=None		,						)    ->				str:
							UpperCAmelCase_=     parent
							UpperCAmelCase_=     batch_size
							UpperCAmelCase_=     seq_length
							UpperCAmelCase_=     is_training
							UpperCAmelCase_=     use_input_mask
							UpperCAmelCase_=     use_token_type_ids
							UpperCAmelCase_=     use_labels
							UpperCAmelCase_=     vocab_size
							UpperCAmelCase_=     hidden_size
							UpperCAmelCase_=     num_hidden_layers
							UpperCAmelCase_=     num_attention_heads
							UpperCAmelCase_=     intermediate_size
							UpperCAmelCase_=     hidden_act
							UpperCAmelCase_=     hidden_dropout_prob
							UpperCAmelCase_=     attention_probs_dropout_prob
							UpperCAmelCase_=     max_position_embeddings
							UpperCAmelCase_=     type_vocab_size
							UpperCAmelCase_=     type_sequence_label_size
							UpperCAmelCase_=     initializer_range
							UpperCAmelCase_=     num_labels
							UpperCAmelCase_=     num_choices
							UpperCAmelCase_=     scope




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Tuple  )    ->				str:
							UpperCAmelCase_=     ids_tensor([self.batch_size, self.seq_length]		,						self.vocab_size  )

							UpperCAmelCase_=     None
							if self.use_input_mask:
													UpperCAmelCase_=     random_attention_mask([self.batch_size, self.seq_length]  )

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

							UpperCAmelCase_=     None
							UpperCAmelCase_=     None
							UpperCAmelCase_=     None
							if self.use_labels:
													UpperCAmelCase_=     ids_tensor([self.batch_size]		,						self.type_sequence_label_size  )
													UpperCAmelCase_=     ids_tensor([self.batch_size, self.seq_length]		,						self.num_labels  )
													UpperCAmelCase_=     ids_tensor([self.batch_size]		,						self.num_choices  )

							UpperCAmelCase_=     self.get_config()

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




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				List[str]:
							return YosoConfig(
							    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=__UpperCAmelCase		,						initializer_range=self.initializer_range		,						)




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Union[str, Any]:
							UpperCAmelCase_=     self.get_config()
							UpperCAmelCase_=     300
							return config




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]  )    ->				str:
							(
							    (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     
							)=     self.prepare_config_and_inputs()

							UpperCAmelCase_=     True
							UpperCAmelCase_=     floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
							UpperCAmelCase_=     ids_tensor([self.batch_size, self.seq_length]		,						vocab_size=2  )

							return (
							    config,
							    input_ids,
							    token_type_ids,
							    input_mask,
							    sequence_labels,
							    token_labels,
							    choice_labels,
							    encoder_hidden_states,
							    encoder_attention_mask,
							)




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		int		,						__UpperCAmelCase			:		Union[str, Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Any  )    ->				List[Any]:
							UpperCAmelCase_=     YosoModel(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase  )
							UpperCAmelCase_=     model(__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase  )
							UpperCAmelCase_=     model(__UpperCAmelCase  )
							self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		Dict		,						)    ->				List[str]:
							UpperCAmelCase_=     True
							UpperCAmelCase_=     YosoModel(__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(
							    __UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						encoder_hidden_states=__UpperCAmelCase		,						encoder_attention_mask=__UpperCAmelCase		,						)
							UpperCAmelCase_=     model(
							    __UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						encoder_hidden_states=__UpperCAmelCase		,						)
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase  )
							self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		str		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		str  )    ->				List[Any]:
							UpperCAmelCase_=     YosoForMaskedLM(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						labels=__UpperCAmelCase  )
							self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.vocab_size)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[Any]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Tuple		,						__UpperCAmelCase			:		Tuple		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		Optional[int]  )    ->				List[Any]:
							UpperCAmelCase_=     YosoForQuestionAnswering(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(
							    __UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						start_positions=__UpperCAmelCase		,						end_positions=__UpperCAmelCase		,						)
							self.parent.assertEqual(result.start_logits.shape		,						(self.batch_size, self.seq_length)  )
							self.parent.assertEqual(result.end_logits.shape		,						(self.batch_size, self.seq_length)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any		,						__UpperCAmelCase			:		Dict		,						__UpperCAmelCase			:		Union[str, Any]		,						__UpperCAmelCase			:		Tuple		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		List[str]  )    ->				str:
							UpperCAmelCase_=     self.num_labels
							UpperCAmelCase_=     YosoForSequenceClassification(__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						labels=__UpperCAmelCase  )
							self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_labels)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		int		,						__UpperCAmelCase			:		Union[str, Any]		,						__UpperCAmelCase			:		Optional[Any]		,						__UpperCAmelCase			:		Tuple  )    ->				Union[str, Any]:
							UpperCAmelCase_=     self.num_labels
							UpperCAmelCase_=     YosoForTokenClassification(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     model(__UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						labels=__UpperCAmelCase  )
							self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.num_labels)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		str		,						__UpperCAmelCase			:		Optional[int]		,						__UpperCAmelCase			:		List[str]		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		List[Any]		,						__UpperCAmelCase			:		str		,						__UpperCAmelCase			:		Any		,						__UpperCAmelCase			:		Optional[int]  )    ->				Any:
							UpperCAmelCase_=     self.num_choices
							UpperCAmelCase_=     YosoForMultipleChoice(config=__UpperCAmelCase  )
							model.to(__UpperCAmelCase  )
							model.eval()
							UpperCAmelCase_=     input_ids.unsqueeze(1  ).expand(-1		,						self.num_choices		,						-1  ).contiguous()
							UpperCAmelCase_=     token_type_ids.unsqueeze(1  ).expand(-1		,						self.num_choices		,						-1  ).contiguous()
							UpperCAmelCase_=     input_mask.unsqueeze(1  ).expand(-1		,						self.num_choices		,						-1  ).contiguous()
							UpperCAmelCase_=     model(
							    __UpperCAmelCase		,						attention_mask=__UpperCAmelCase		,						token_type_ids=__UpperCAmelCase		,						labels=__UpperCAmelCase		,						)
							self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_choices)  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Any:
							UpperCAmelCase_=     self.prepare_config_and_inputs()
							(
							    (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     (
							    UpperCAmelCase_
							),     
							)=     config_and_inputs
							UpperCAmelCase_=     {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
							return config, inputs_dict






@require_torch
class 	lowercase		(				snake_case__				,					snake_case__				,					unittest.TestCase):






	"""simple docstring"""


	a__   :      Any	     =							(
	    (
	        YosoModel,
	        YosoForMaskedLM,
	        YosoForMultipleChoice,
	        YosoForQuestionAnswering,
	        YosoForSequenceClassification,
	        YosoForTokenClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	a__   :      Optional[int]	     =							False
	a__   :      Optional[Any]	     =							False
	a__   :      Dict	     =							False

	a__   :      int	     =							()
	a__   :      int	     =							(
	    {
	        "feature-extraction": YosoModel,
	        "fill-mask": YosoForMaskedLM,
	        "question-answering": YosoForQuestionAnswering,
	        "text-classification": YosoForSequenceClassification,
	        "token-classification": YosoForTokenClassification,
	        "zero-shot": YosoForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Optional[int]:
							UpperCAmelCase_=     YosoModelTester(self  )
							UpperCAmelCase_=     ConfigTester(self		,						config_class=__UpperCAmelCase		,						hidden_size=37  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				Union[str, Any]:
							self.config_tester.run_common_tests()




	def 						_SCREAMING_SNAKE_CASE	(			self			:		List[str]  )    ->				Dict:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[int]  )    ->				Any:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							for type in ["absolute", "relative_key", "relative_key_query"]:
													UpperCAmelCase_=     type
													self.model_tester.create_and_check_model(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		int  )    ->				Any:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Any  )    ->				Optional[int]:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Optional[Any]  )    ->				Dict:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				int:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Optional[Any]:
							UpperCAmelCase_=     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*__UpperCAmelCase  )




	@slow
	def 						_SCREAMING_SNAKE_CASE	(			self			:		Union[str, Any]  )    ->				Optional[Any]:
							for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase_=     YosoModel.from_pretrained(__UpperCAmelCase  )
													self.assertIsNotNone(__UpperCAmelCase  )




	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Tuple:
							return






@require_torch
class 	lowercase		(				unittest.TestCase):






	"""simple docstring"""


	@slow
	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Optional[int]:
							UpperCAmelCase_=     YosoModel.from_pretrained("""uw-madison/yoso-4096"""  )
							UpperCAmelCase_=     torch.tensor([[0, 1, 2, 3, 4, 5]]  )

							with torch.no_grad():
													UpperCAmelCase_=     model(__UpperCAmelCase  )[0]

							UpperCAmelCase_=     torch.Size((1, 6, 768)  )
							self.assertEqual(output.shape		,						__UpperCAmelCase  )

							UpperCAmelCase_=     torch.tensor(
							    [[[-0.0_611, 0.1_242, 0.0_840], [0.0_280, -0.0_048, 0.1_125], [0.0_106, 0.0_226, 0.0_751]]]  )

							self.assertTrue(torch.allclose(output[:, :3, :3]		,						__UpperCAmelCase		,						atol=1E-4  )  )




	@slow
	def 						_SCREAMING_SNAKE_CASE	(			self			:		str  )    ->				List[Any]:
							UpperCAmelCase_=     YosoForMaskedLM.from_pretrained("""uw-madison/yoso-4096"""  )
							UpperCAmelCase_=     torch.tensor([[0, 1, 2, 3, 4, 5]]  )

							with torch.no_grad():
													UpperCAmelCase_=     model(__UpperCAmelCase  )[0]

							UpperCAmelCase_=     50_265

							UpperCAmelCase_=     torch.Size((1, 6, vocab_size)  )
							self.assertEqual(output.shape		,						__UpperCAmelCase  )

							UpperCAmelCase_=     torch.tensor(
							    [[[-2.1_313, -3.7_285, -2.2_407], [-2.7_047, -3.3_314, -2.6_408], [0.0_629, -2.5_166, -0.3_356]]]  )

							self.assertTrue(torch.allclose(output[:, :3, :3]		,						__UpperCAmelCase		,						atol=1E-4  )  )




	@slow
	def 						_SCREAMING_SNAKE_CASE	(			self			:		Dict  )    ->				Tuple:
							UpperCAmelCase_=     YosoForMaskedLM.from_pretrained("""uw-madison/yoso-4096"""  )
							UpperCAmelCase_=     torch.arange(4_096  ).unsqueeze(0  )

							with torch.no_grad():
													UpperCAmelCase_=     model(__UpperCAmelCase  )[0]

							UpperCAmelCase_=     50_265

							UpperCAmelCase_=     torch.Size((1, 4_096, vocab_size)  )
							self.assertEqual(output.shape		,						__UpperCAmelCase  )

							UpperCAmelCase_=     torch.tensor(
							    [[[-2.3_914, -4.3_742, -5.0_956], [-4.0_988, -4.2_384, -7.0_406], [-3.1_427, -3.7_192, -6.6_800]]]  )

							self.assertTrue(torch.allclose(output[:, :3, :3]		,						__UpperCAmelCase		,						atol=1E-4  )  )









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()




