
'''simple docstring'''

import argparse
import json
import os

import fairseq
import torch
from torch import nn

from transformers import (
    SpeechaTextaConfig,
    SpeechaTextaForCausalLM,
    SpeechaTextaTokenizer,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
UpperCAmelCase__ :			List[Any]											=		logging.get_logger(__name__)

UpperCAmelCase__ :			str											=		{
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
    "fc2": "encoder.layers.*.feed_forward.output_dense",
    "final_layer_norm": "encoder.layers.*.final_layer_norm",
    "encoder.layer_norm": "encoder.layer_norm",
    "w2v_model.layer_norm": "feature_projection.layer_norm",
    "quantizer.weight_proj": "quantizer.weight_proj",
    "quantizer.vars": "quantizer.codevectors",
    "project_q": "project_q",
    "final_proj": "project_hid",
    "w2v_encoder.proj": "lm_head",
    "mask_emb": "masked_spec_embed",
}
UpperCAmelCase__ :			List[str]											=		[
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]







def 	A  (   UpperCamelCase_       :  Union[str, Any]    ,						UpperCamelCase_       :  Dict    ,						UpperCamelCase_       :  Optional[Any]    ,						UpperCamelCase_       :  Union[str, Any]    ,						UpperCamelCase_       :  Dict   )       ->							Any:







			'''simple docstring'''



			for attribute in key.split("."   ):
						lowerCAmelCase__										=				getattr(UpperCamelCase_    ,						UpperCamelCase_   )

			if weight_type is not None:
						lowerCAmelCase__										=				getattr(UpperCamelCase_    ,						UpperCamelCase_   ).shape
			else:
						lowerCAmelCase__										=				hf_pointer.shape

			assert hf_shape == value.shape, (
			    F"""Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be"""
			    F""" {value.shape} for {full_name}"""
			)

			if weight_type == "weight":
						lowerCAmelCase__										=				value
			elif weight_type == "weight_g":
						lowerCAmelCase__										=				value
			elif weight_type == "weight_v":
						lowerCAmelCase__										=				value
			elif weight_type == "bias":
						lowerCAmelCase__										=				value
			else:
						lowerCAmelCase__										=				value

			logger.info(F"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}."""   )







def 	A  (   UpperCamelCase_       :  Dict    ,						UpperCamelCase_       :  Any   )       ->							Dict:







			'''simple docstring'''



			lowerCAmelCase__										=				[]
			lowerCAmelCase__										=				fairseq_model.state_dict()

			lowerCAmelCase__										=				hf_model.feature_extractor

			# if encoder has different dim to decoder -> use proj_weight
			lowerCAmelCase__										=				None

			for name, value in fairseq_dict.items():
						lowerCAmelCase__										=				False
						if "conv_layers" in name:
									load_conv_layer(
									    UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_    ,						hf_model.config.feat_extract_norm == "group"    ,						)
									lowerCAmelCase__										=				True
						elif name.split("."   )[0] == "proj":
									lowerCAmelCase__										=				fairseq_model.proj
									lowerCAmelCase__										=				True
						else:
									for key, mapped_key in MAPPING.items():
												if key in name or key.split("w2v_model."   )[-1] == name.split("."   )[0]:
															lowerCAmelCase__										=				True
															if "*" in mapped_key:
																		lowerCAmelCase__										=				name.split(UpperCamelCase_   )[0].split("."   )[-2]
																		lowerCAmelCase__										=				mapped_key.replace("*"    ,						UpperCamelCase_   )
															if "weight_g" in name:
																		lowerCAmelCase__										=				"weight_g"
															elif "weight_v" in name:
																		lowerCAmelCase__										=				"weight_v"
															elif "bias" in name:
																		lowerCAmelCase__										=				"bias"
															elif "weight" in name:
																		lowerCAmelCase__										=				"weight"
															else:
																		lowerCAmelCase__										=				None
															set_recursively(UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_   )
												continue
						if not is_used:
									unused_weights.append(UpperCamelCase_   )

			logger.warning(F"""Unused weights: {unused_weights}"""   )

			return proj_weight







def 	A  (   UpperCamelCase_       :  List[str]    ,						UpperCamelCase_       :  Any    ,						UpperCamelCase_       :  str    ,						UpperCamelCase_       :  List[Any]    ,						UpperCamelCase_       :  str   )       ->							List[str]:







			'''simple docstring'''



			lowerCAmelCase__										=				full_name.split("conv_layers."   )[-1]
			lowerCAmelCase__										=				name.split("."   )
			lowerCAmelCase__										=				int(items[0]   )
			lowerCAmelCase__										=				int(items[1]   )

			if type_id == 0:
						if "bias" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
									    F"""{full_name} has size {value.shape}, but"""
									    F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."""
									)
									lowerCAmelCase__										=				value
									logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""   )
						elif "weight" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
									    F"""{full_name} has size {value.shape}, but"""
									    F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."""
									)
									lowerCAmelCase__										=				value
									logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""   )
			elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
						if "bias" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
									    F"""{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"""
									    " found."
									)
									lowerCAmelCase__										=				value
									logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""   )
						elif "weight" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
									    F"""{full_name} has size {value.shape}, but"""
									    F""" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."""
									)
									lowerCAmelCase__										=				value
									logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""   )
			else:
						unused_weights.append(UpperCamelCase_   )







def 	A  (   UpperCamelCase_       :  Dict   )       ->							Tuple:







			'''simple docstring'''



			lowerCAmelCase__						,lowerCAmelCase__										=				emb.weight.shape
			lowerCAmelCase__										=				nn.Linear(UpperCamelCase_    ,						UpperCamelCase_    ,						bias=UpperCamelCase_   )
			lowerCAmelCase__										=				emb.weight.data
			return lin_layer







def 	A  (   UpperCamelCase_       :  Optional[Any]   )       ->							Dict:







			'''simple docstring'''



			with open(UpperCamelCase_    ,						"r"    ,						encoding="utf-8"   ) as f:
						lowerCAmelCase__										=				f.readlines()
						lowerCAmelCase__										=				[line.split(" "   )[0] for line in lines]

			lowerCAmelCase__										=				len(UpperCamelCase_   )

			lowerCAmelCase__										=				{
			    "<s>": 0,
			    "<pad>": 1,
			    "</s>": 2,
			    "<unk>": 3,
			}

			vocab_dict.update(dict(zip(UpperCamelCase_    ,						range(4    ,						num_words + 4   )   )   )   )
			return vocab_dict







@torch.no_grad()
def 	A  (   UpperCamelCase_       :  Optional[int]    ,						UpperCamelCase_       :  Tuple    ,						UpperCamelCase_       :  int    ,						UpperCamelCase_       :  Dict    ,						UpperCamelCase_       :  List[str]    ,						UpperCamelCase_       :  List[Any]    ,						UpperCamelCase_       :  Optional[int]    ,						)       ->							str:







			'''simple docstring'''



			lowerCAmelCase__										=				WavaVecaConfig.from_pretrained(UpperCamelCase_   )
			lowerCAmelCase__										=				SpeechaTextaConfig.from_pretrained(
			    UpperCamelCase_    ,						vocab_size=UpperCamelCase_    ,						decoder_layers=UpperCamelCase_    ,						do_stable_layer_norm=UpperCamelCase_   )

			lowerCAmelCase__										=				WavaVecaFeatureExtractor(
			    feature_size=1    ,						sampling_rate=1_60_00    ,						padding_value=0    ,						do_normalize=UpperCamelCase_    ,						return_attention_mask=UpperCamelCase_    ,						)

			lowerCAmelCase__						,lowerCAmelCase__						,lowerCAmelCase__										=				fairseq.checkpoint_utils.load_model_ensemble_and_task(
			    [checkpoint_path]    ,						arg_overrides={"data": "/".join(dict_path.split("/"   )[:-1]   )}   )
			lowerCAmelCase__										=				model[0].eval()

			# set weights for wav2vec2 encoder
			lowerCAmelCase__										=				WavaVecaModel(UpperCamelCase_   )
			lowerCAmelCase__										=				recursively_load_weights_wavaveca(model.encoder    ,						UpperCamelCase_   )

			lowerCAmelCase__										=				SpeechaTextaForCausalLM(UpperCamelCase_   )
			lowerCAmelCase__						,lowerCAmelCase__										=				hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()    ,						strict=UpperCamelCase_   )

			# set output linear layer
			unexpected_keys.remove("embed_out"   )
			lowerCAmelCase__										=				nn.Parameter(model.decoder.embed_out.detach()   )

			# layer norm is init to identity matrix so leaving it is fine
			logger.warning(F"""The following keys are missing when loading the decoder weights: {missing_keys}"""   )
			logger.warning(F"""The following keys are unexpected when loading the decoder weights: {unexpected_keys}"""   )

			lowerCAmelCase__										=				SpeechEncoderDecoderModel(encoder=UpperCamelCase_    ,						decoder=UpperCamelCase_   )
			lowerCAmelCase__										=				False

			# add projection layer
			lowerCAmelCase__										=				nn.Parameter(projection_layer.weight   )
			lowerCAmelCase__										=				nn.Parameter(projection_layer.bias   )

			lowerCAmelCase__										=				create_vocab_dict(UpperCamelCase_   )

			with open(os.path.join(UpperCamelCase_    ,						"vocab.json"   )    ,						"w"   ) as fp:
						json.dump(UpperCamelCase_    ,						UpperCamelCase_   )

			lowerCAmelCase__										=				SpeechaTextaTokenizer(os.path.join(UpperCamelCase_    ,						"vocab.json"   )   )
			tokenizer.save_pretrained(UpperCamelCase_   )

			lowerCAmelCase__										=				hf_wavavec.config.to_dict()
			lowerCAmelCase__										=				tokenizer.pad_token_id
			lowerCAmelCase__										=				tokenizer.bos_token_id
			lowerCAmelCase__										=				tokenizer.eos_token_id
			lowerCAmelCase__										=				"speech_to_text_2"
			lowerCAmelCase__										=				"wav2vec2"

			lowerCAmelCase__										=				SpeechEncoderDecoderConfig.from_dict(UpperCamelCase_   )

			hf_wavavec.save_pretrained(UpperCamelCase_   )
			feature_extractor.save_pretrained(UpperCamelCase_   )


if __name__ == "__main__":
		UpperCAmelCase__ :			Optional[Any]											=		argparse.ArgumentParser()
		parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
		parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
		parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
		parser.add_argument(
		    "--encoder_config_path",
		    default="facebook/wav2vec2-large-lv60",
		    type=str,
		    help="Path to hf encoder wav2vec2 checkpoint config",
		)
		parser.add_argument(
		    "--decoder_config_path",
		    default="facebook/s2t-small-mustc-en-fr-st",
		    type=str,
		    help="Path to hf decoder s2t checkpoint config",
		)
		parser.add_argument("--vocab_size", default=1_02_24, type=int, help="Vocab size of decoder")
		parser.add_argument("--num_decoder_layers", default=7, type=int, help="Number of decoder layers")

		UpperCAmelCase__ :			str											=		parser.parse_args()
		convert_wavaveca_checkpoint(
		    args.checkpoint_path,
		    args.pytorch_dump_folder_path,
		    args.dict_path,
		    encoder_config_path=args.encoder_config_path,
		    decoder_config_path=args.decoder_config_path,
		    vocab_size=args.vocab_size,
		    num_decoder_layers=args.num_decoder_layers,
		)







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

import pytest

from .sola import PokerHand

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

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

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

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

lowercase   =	(
    ('''2H 4D 3C AS 5S''', True, [5, 4, 3, 2, 1_4]),
    ('''2H 5D 3C AS 5S''', False, [1_4, 5, 5, 3, 2]),
    ('''JH QD KC AS TS''', False, [1_4, 1_3, 1_2, 1_1, 1_0]),
    ('''9D 3S 2C 7S 7C''', False, [9, 7, 7, 3, 2]),
)

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

lowercase   =	(
    ('''JH AH TH KH QH''', 2_3),
    ('''JH 9H TH KH QH''', 2_2),
    ('''JC KH JS JD JH''', 2_1),
    ('''KH KC 3S 3H 3D''', 2_0),
    ('''8C 9C 5C 3C TC''', 1_9),
    ('''JS QS 9H TS KH''', 1_8),
    ('''7C 7S KH 2H 7H''', 1_7),
    ('''3C KH 5D 5S KH''', 1_6),
    ('''QH 8H KD JH 8S''', 1_5),
    ('''2D 6D 9D TH 7D''', 1_4),
)



def   __lowerCAmelCase    (				)	->     List[str]:
							lowerCamelCase_	, lowerCamelCase_					=       randrange(len(UpperCAmelCase__							)							), randrange(len(UpperCAmelCase__							)							)
							lowerCamelCase_					=       ["""Loss""", """Tie""", """Win"""][(play >= oppo) + (play > oppo)]
							lowerCamelCase_	, lowerCamelCase_					=       SORTED_HANDS[play], SORTED_HANDS[oppo]
							return hand, other, expected



def   __lowerCAmelCase    (				UpperCAmelCase__					:   int = 1_0_0							)	->     Optional[int]:
							return (generate_random_hand() for _ in range(UpperCAmelCase__							))



@pytest.mark.parametrize("""hand, expected"""      ,					UpperCAmelCase__							)
def   __lowerCAmelCase    (				UpperCAmelCase__					:   Union[str, Any]      ,					UpperCAmelCase__					:   Union[str, Any]							)	->     List[Any]:
							assert PokerHand(UpperCAmelCase__							)._is_flush() == expected



@pytest.mark.parametrize("""hand, expected"""      ,					UpperCAmelCase__							)
def   __lowerCAmelCase    (				UpperCAmelCase__					:   Tuple      ,					UpperCAmelCase__					:   List[Any]							)	->     int:
							assert PokerHand(UpperCAmelCase__							)._is_straight() == expected



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



@pytest.mark.parametrize("""hand, expected"""      ,					UpperCAmelCase__							)
def   __lowerCAmelCase    (				UpperCAmelCase__					:   List[Any]      ,					UpperCAmelCase__					:   Dict							)	->     str:
							assert PokerHand(UpperCAmelCase__							)._is_same_kind() == expected



@pytest.mark.parametrize("""hand, expected"""      ,					UpperCAmelCase__							)
def   __lowerCAmelCase    (				UpperCAmelCase__					:   Any      ,					UpperCAmelCase__					:   Dict							)	->     Tuple:
							assert PokerHand(UpperCAmelCase__							)._hand_type == expected



@pytest.mark.parametrize("""hand, other, expected"""      ,					UpperCAmelCase__							)
def   __lowerCAmelCase    (				UpperCAmelCase__					:   int      ,					UpperCAmelCase__					:   Tuple      ,					UpperCAmelCase__					:   Union[str, Any]							)	->     Any:
							assert PokerHand(UpperCAmelCase__							).compare_with(PokerHand(UpperCAmelCase__							)							) == expected



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



def   __lowerCAmelCase    (				)	->     Tuple:
							lowerCamelCase_					=       [PokerHand(UpperCAmelCase__							) for hand in SORTED_HANDS]
							lowerCamelCase_					=       poker_hands.copy()
							shuffle(UpperCAmelCase__							)
							lowerCamelCase_					=       chain(sorted(UpperCAmelCase__							)							)
							for index, hand in enumerate(UpperCAmelCase__							):
														assert hand == poker_hands[index]



def   __lowerCAmelCase    (				)	->     List[Any]:
							# Test that five high straights are compared correctly.
							lowerCamelCase_					=       [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   __lowerCAmelCase    (				)	->     List[str]:
							# Multiple calls to five_high_straight function should still return True
							# and shouldn't mutate the list in every call other than the first.
							lowerCamelCase_					=       PokerHand("""2C 4S AS 3D 5C"""							)
							lowerCamelCase_					=       True
							lowerCamelCase_					=       [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   __lowerCAmelCase    (				)	->     List[Any]:
							# Problem number 54 from Project Euler
							# Testing from poker_hands.txt file
							lowerCamelCase_					=       0
							lowerCamelCase_					=       os.path.abspath(os.path.dirname(UpperCAmelCase__							)							)
							lowerCamelCase_					=       os.path.join(UpperCAmelCase__      ,					"""poker_hands.txt"""							)
							with open(UpperCAmelCase__							) as file_hand:
														for line in file_hand:
																					lowerCamelCase_					=       line[:1_4].strip()
																					lowerCamelCase_					=       line[1_5:].strip()
																					lowerCamelCase_	, lowerCamelCase_					=       PokerHand(UpperCAmelCase__							), PokerHand(UpperCAmelCase__							)
																					lowerCamelCase_					=       player.compare_with(UpperCAmelCase__							)
																					if output == "Win":
																												answer += 1
							assert answer == 3_7_6





