


import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
						from transformers import SpeechaTextFeatureExtractor

snake_case							: Optional[Any]      =   random.Random()






def 							__lowercase     (				__lowerCAmelCase							:       Optional[Any]      ,					__lowerCAmelCase							:       Dict=1.0      ,					__lowerCAmelCase							:       Optional[Any]=None      ,					__lowerCAmelCase							:       List[Any]=None     ):
							if rng is None:
														a__    =  global_rng

							a__    =  []
							for batch_idx in range(shape[0]     ):
														values.append([]     )
														for _ in range(shape[1]     ):
																					values[-1].append(rng.random() * scale     )

							return values







@require_torch
@require_torchaudio
class  snake_case_     (unittest.TestCase   ):
					def __init__(   self     :Any    ,__snake_case     :Tuple    ,__snake_case     :Optional[int]=7    ,__snake_case     :List[Any]=4_00    ,__snake_case     :Optional[int]=20_00    ,__snake_case     :Tuple=24    ,__snake_case     :Union[str, Any]=24    ,__snake_case     :int=0.0    ,__snake_case     :str=1_60_00    ,__snake_case     :int=True    ,__snake_case     :Any=True    ,)      ->					Optional[Any]:
												a__    =  parent
												a__    =  batch_size
												a__    =  min_seq_length
												a__    =  max_seq_length
												a__    =  (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
												a__    =  feature_size
												a__    =  num_mel_bins
												a__    =  padding_value
												a__    =  sampling_rate
												a__    =  return_attention_mask
												a__    =  do_normalize
					def 				lowerCamelCase__(   self     :str   )      ->					Any:
												return {
												    "feature_size": self.feature_size,
												    "num_mel_bins": self.num_mel_bins,
												    "padding_value": self.padding_value,
												    "sampling_rate": self.sampling_rate,
												    "return_attention_mask": self.return_attention_mask,
												    "do_normalize": self.do_normalize,
												}



					def 				lowerCamelCase__(   self     :List[Any]    ,__snake_case     :List[Any]=False    ,__snake_case     :Optional[int]=False   )      ->					Dict:
												def _flatten(__snake_case     :str   ):
																			return list(itertools.chain(*__snake_case   )   )

												if equal_length:
																			a__    =  [floats_list((self.max_seq_length, self.feature_size)   ) for _ in range(self.batch_size   )]
												else:
																			# make sure that inputs increase in size
																			a__    =  [
																			    floats_list((x, self.feature_size)   )
																			    for x in range(self.min_seq_length    ,self.max_seq_length    ,self.seq_length_diff   )
																			]
												if numpify:
																			a__    =  [np.asarray(__snake_case   ) for x in speech_inputs]
												return speech_inputs







@require_torch
@require_torchaudio
class  snake_case_     (lowerCamelCase_			,		unittest.TestCase   ):
					UpperCAmelCase__      :					str					   =    SpeechaTextFeatureExtractor if is_speech_available() else None
					def 				lowerCamelCase__(   self     :Optional[Any]   )      ->					Dict:
												a__    =  SpeechaTextFeatureExtractionTester(self   )
					def 				lowerCamelCase__(   self     :int    ,__snake_case     :List[str]   )      ->					Optional[int]:
												self.assertTrue(np.all(np.mean(__snake_case    ,axis=0   ) < 1E-3   )   )
												self.assertTrue(np.all(np.abs(np.var(__snake_case    ,axis=0   ) - 1   ) < 1E-3   )   )
					def 				lowerCamelCase__(   self     :List[Any]   )      ->					Tuple:
												# Tests that all call wrap to encode_plus and batch_encode_plus
												a__    =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
												# create three inputs of length 800, 1000, and 1200
												a__    =  [floats_list((1, x)   )[0] for x in range(8_00    ,14_00    ,2_00   )]
												a__    =  [np.asarray(__snake_case   ) for speech_input in speech_inputs]

												# Test feature size
												a__    =  feature_extractor(__snake_case    ,padding=__snake_case    ,return_tensors='np'   ).input_features
												self.assertTrue(input_features.ndim == 3   )
												self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size   )

												# Test not batched input
												a__    =  feature_extractor(speech_inputs[0]    ,return_tensors='np'   ).input_features
												a__    =  feature_extractor(np_speech_inputs[0]    ,return_tensors='np'   ).input_features
												self.assertTrue(np.allclose(__snake_case    ,__snake_case    ,atol=1E-3   )   )

												# Test batched
												a__    =  feature_extractor(__snake_case    ,return_tensors='np'   ).input_features
												a__    =  feature_extractor(__snake_case    ,return_tensors='np'   ).input_features
												for enc_seq_a, enc_seq_a in zip(__snake_case    ,__snake_case   ):
																			self.assertTrue(np.allclose(__snake_case    ,__snake_case    ,atol=1E-3   )   )

												# Test 2-D numpy arrays are batched.
												a__    =  [floats_list((1, x)   )[0] for x in (8_00, 8_00, 8_00)]
												a__    =  np.asarray(__snake_case   )
												a__    =  feature_extractor(__snake_case    ,return_tensors='np'   ).input_features
												a__    =  feature_extractor(__snake_case    ,return_tensors='np'   ).input_features
												for enc_seq_a, enc_seq_a in zip(__snake_case    ,__snake_case   ):
																			self.assertTrue(np.allclose(__snake_case    ,__snake_case    ,atol=1E-3   )   )
					def 				lowerCamelCase__(   self     :List[str]   )      ->					str:
												a__    =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
												a__    =  [floats_list((1, x)   )[0] for x in range(8_00    ,14_00    ,2_00   )]

												a__    =  ['longest', 'max_length', 'do_not_pad']
												a__    =  [None, 16, None]
												for max_length, padding in zip(__snake_case    ,__snake_case   ):
																			a__    =  feature_extractor(
																			    __snake_case    ,padding=__snake_case    ,max_length=__snake_case    ,return_attention_mask=__snake_case   )
																			a__    =  inputs.input_features
																			a__    =  inputs.attention_mask
																			a__    =  [np.sum(__snake_case   ) for x in attention_mask]

																			self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]   )
																			self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]   )
																			self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]   )
					def 				lowerCamelCase__(   self     :Dict   )      ->					Dict:
												a__    =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
												a__    =  [floats_list((1, x)   )[0] for x in range(8_00    ,14_00    ,2_00   )]

												a__    =  ['longest', 'max_length', 'do_not_pad']
												a__    =  [None, 16, None]
												for max_length, padding in zip(__snake_case    ,__snake_case   ):
																			a__    =  feature_extractor(
																			    __snake_case    ,max_length=__snake_case    ,padding=__snake_case    ,return_tensors='np'    ,return_attention_mask=__snake_case   )
																			a__    =  inputs.input_features
																			a__    =  inputs.attention_mask
																			a__    =  [np.sum(__snake_case   ) for x in attention_mask]

																			self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]   )
																			self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6   )
																			self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]   )
																			self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6   )
																			self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]   )
					def 				lowerCamelCase__(   self     :Optional[int]   )      ->					int:
												a__    =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
												a__    =  [floats_list((1, x)   )[0] for x in range(8_00    ,14_00    ,2_00   )]
												a__    =  feature_extractor(
												    __snake_case    ,padding='max_length'    ,max_length=4    ,truncation=__snake_case    ,return_tensors='np'    ,return_attention_mask=__snake_case    ,)
												a__    =  inputs.input_features
												a__    =  inputs.attention_mask
												a__    =  np.sum(attention_mask == 1    ,axis=1   )

												self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]   )
												self._check_zero_mean_unit_variance(input_features[1]   )
												self._check_zero_mean_unit_variance(input_features[2]   )
					def 				lowerCamelCase__(   self     :Tuple   )      ->					List[str]:
												a__    =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
												a__    =  [floats_list((1, x)   )[0] for x in range(8_00    ,14_00    ,2_00   )]
												a__    =  feature_extractor(
												    __snake_case    ,padding='longest'    ,max_length=4    ,truncation=__snake_case    ,return_tensors='np'    ,return_attention_mask=__snake_case    ,)
												a__    =  inputs.input_features
												a__    =  inputs.attention_mask
												a__    =  np.sum(attention_mask == 1    ,axis=1   )

												self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]   )
												self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]   )
												self._check_zero_mean_unit_variance(input_features[2]   )

												# make sure that if max_length < longest -> then pad to max_length
												self.assertEqual(input_features.shape    ,(3, 4, 24)   )

												a__    =  [floats_list((1, x)   )[0] for x in range(8_00    ,14_00    ,2_00   )]
												a__    =  feature_extractor(
												    __snake_case    ,padding='longest'    ,max_length=16    ,truncation=__snake_case    ,return_tensors='np'    ,return_attention_mask=__snake_case    ,)
												a__    =  inputs.input_features
												a__    =  inputs.attention_mask
												a__    =  np.sum(attention_mask == 1    ,axis=1   )

												self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]   )
												self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]   )
												self._check_zero_mean_unit_variance(input_features[2]   )

												# make sure that if max_length < longest -> then pad to max_length
												self.assertEqual(input_features.shape    ,(3, 6, 24)   )
					def 				lowerCamelCase__(   self     :str   )      ->					int:
												import torch

												a__    =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
												a__    =  np.random.rand(1_00    ,32   ).astype(np.floataa   )
												a__    =  np_speech_inputs.tolist()

												for inputs in [py_speech_inputs, np_speech_inputs]:
																			a__    =  feature_extractor.pad([{'input_features': inputs}]    ,return_tensors='np'   )
																			self.assertTrue(np_processed.input_features.dtype == np.floataa   )
																			a__    =  feature_extractor.pad([{'input_features': inputs}]    ,return_tensors='pt'   )
																			self.assertTrue(pt_processed.input_features.dtype == torch.floataa   )
					def 				lowerCamelCase__(   self     :Dict    ,__snake_case     :List[str]   )      ->					Optional[Any]:
												from datasets import load_dataset

												a__    =  load_dataset('hf-internal-testing/librispeech_asr_dummy'    ,'clean'    ,split='validation'   )
												# automatic decoding with librispeech
												a__    =  ds.sort('id'   ).select(range(__snake_case   )   )[:num_samples]['audio']

												return [x["array"] for x in speech_samples]



					def 				lowerCamelCase__(   self     :str   )      ->					List[str]:
												# fmt: off
												a__    =  np.array([
												    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
												    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
												    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
												]   )
												# fmt: on

												a__    =  self._load_datasamples(1   )
												a__    =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
												a__    =  feature_extractor(__snake_case    ,return_tensors='pt'   ).input_features
												self.assertEquals(input_features.shape    ,(1, 5_84, 24)   )
												self.assertTrue(np.allclose(input_features[0, 0, :30]    ,__snake_case    ,atol=1E-4   )   )






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

import pytest

from .sola import PokerHand

snake_case							: str      =   (
    '''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)
)

snake_case							: str      =   (
    ('''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'''),
)

snake_case							: str      =   (
    ('''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),
)

snake_case							: Tuple      =   (
    ('''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),
)

snake_case							: str      =   (
    ('''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]),
)

snake_case							: Tuple      =   (
    ('''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),
)

snake_case							: int      =   (
    ('''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 							__lowercase     (				):
							a__   ,      a__    =  randrange(len(__lowerCAmelCase     )     ), randrange(len(__lowerCAmelCase     )     )
							a__    =  ['Loss', 'Tie', 'Win'][(play >= oppo) + (play > oppo)]
							a__   ,      a__    =  SORTED_HANDS[play], SORTED_HANDS[oppo]
							return hand, other, expected






def 							__lowercase     (				__lowerCAmelCase							:       int = 1_0_0     ):
							return (generate_random_hand() for _ in range(__lowerCAmelCase     ))






@pytest.mark.parametrize('hand, expected'      ,					__lowerCAmelCase     )
def 							__lowercase     (				__lowerCAmelCase							:       Dict      ,					__lowerCAmelCase							:       List[Any]     ):
							assert PokerHand(__lowerCAmelCase     )._is_flush() == expected






@pytest.mark.parametrize('hand, expected'      ,					__lowerCAmelCase     )
def 							__lowercase     (				__lowerCAmelCase							:       Tuple      ,					__lowerCAmelCase							:       Any     ):
							assert PokerHand(__lowerCAmelCase     )._is_straight() == expected






@pytest.mark.parametrize('hand, expected, card_values'      ,					__lowerCAmelCase     )
def 							__lowercase     (				__lowerCAmelCase							:       str      ,					__lowerCAmelCase							:       Union[str, Any]      ,					__lowerCAmelCase							:       Dict     ):
							a__    =  PokerHand(__lowerCAmelCase     )
							assert player._is_five_high_straight() == expected
							assert player._card_values == card_values






@pytest.mark.parametrize('hand, expected'      ,					__lowerCAmelCase     )
def 							__lowercase     (				__lowerCAmelCase							:       Any      ,					__lowerCAmelCase							:       Tuple     ):
							assert PokerHand(__lowerCAmelCase     )._is_same_kind() == expected






@pytest.mark.parametrize('hand, expected'      ,					__lowerCAmelCase     )
def 							__lowercase     (				__lowerCAmelCase							:       Optional[int]      ,					__lowerCAmelCase							:       Tuple     ):
							assert PokerHand(__lowerCAmelCase     )._hand_type == expected






@pytest.mark.parametrize('hand, other, expected'      ,					__lowerCAmelCase     )
def 							__lowercase     (				__lowerCAmelCase							:       List[str]      ,					__lowerCAmelCase							:       Any      ,					__lowerCAmelCase							:       List[Any]     ):
							assert PokerHand(__lowerCAmelCase     ).compare_with(PokerHand(__lowerCAmelCase     )     ) == expected






@pytest.mark.parametrize('hand, other, expected'      ,					generate_random_hands()     )
def 							__lowercase     (				__lowerCAmelCase							:       str      ,					__lowerCAmelCase							:       Optional[int]      ,					__lowerCAmelCase							:       Tuple     ):
							assert PokerHand(__lowerCAmelCase     ).compare_with(PokerHand(__lowerCAmelCase     )     ) == expected






def 							__lowercase     (				):
							a__    =  [PokerHand(__lowerCAmelCase     ) for hand in SORTED_HANDS]
							a__    =  poker_hands.copy()
							shuffle(__lowerCAmelCase     )
							a__    =  chain(sorted(__lowerCAmelCase     )     )
							for index, hand in enumerate(__lowerCAmelCase     ):
														assert hand == poker_hands[index]






def 							__lowercase     (				):
							# Test that five high straights are compared correctly.
							a__    =  [PokerHand('2D AC 3H 4H 5S'     ), PokerHand('2S 3H 4H 5S 6C'     )]
							pokerhands.sort(reverse=__lowerCAmelCase     )
							assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C"






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




