
'''simple docstring'''


from __future__ import annotations

import os

class 		__lowercase			:
			lowerCamelCase     :						str		 =     (
			    "High card",
			    "One pair",
			    "Two pairs",
			    "Three of a kind",
			    "Straight",
			    "Flush",
			    "Full house",
			    "Four of a kind",
			    "Straight flush",
			    "Royal flush",
			)

			lowerCamelCase     :						Union[str, Any]		 =     (
			    "",  # placeholder as tuples are zero-indexed
			    "One",
			    "Two",
			    "Three",
			    "Four",
			    "Five",
			    "Six",
			    "Seven",
			    "Eight",
			    "Nine",
			    "Ten",
			    "Jack",
			    "Queen",
			    "King",
			    "Ace",
			)

			def __init__(self     ,				A ):
								if not isinstance(A     ,				A ):
													lowerCamelCase_   : Union[str, Any]       =						F"""Hand should be of type 'str': {hand!r}"""
													raise TypeError(A )
								# split removes duplicate whitespaces so no need of strip
								if len(hand.split(''' ''' ) ) != 5:
													lowerCamelCase_   : str       =						F"""Hand should contain only 5 cards: {hand!r}"""
													raise ValueError(A )
								lowerCamelCase_   : int       =						hand
								lowerCamelCase_   : Union[str, Any]       =						0
								lowerCamelCase_   : Tuple       =						0
								lowerCamelCase_, lowerCamelCase_   : str       =						self._internal_state()
								lowerCamelCase_   : Optional[Any]       =						self._get_hand_type()
								lowerCamelCase_   : int       =						self._card_values[0]

			@property
			def     UpperCAmelCase__	(self ):
								return self._hand

			def     UpperCAmelCase__	(self     ,				A ):
								# 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(A )
													else:
																		return "Win" if self._second_pair > other._second_pair else "Loss"
								return "Win" if self._first_pair > other._first_pair else "Loss"

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : Tuple       =						PokerHand._HAND_NAME[self._hand_type - 1_4]
								lowerCamelCase_   : List[Any]       =						PokerHand._CARD_NAME[self._high_card]
								lowerCamelCase_   : List[Any]       =						PokerHand._CARD_NAME[self._first_pair]
								lowerCamelCase_   : List[Any]       =						PokerHand._CARD_NAME[self._second_pair]
								if self._hand_type in [2_2, 1_9, 1_8]:
													return name + F""", {high}-high"""
								elif self._hand_type in [2_1, 1_7, 1_5]:
													return name + F""", {paira}s"""
								elif self._hand_type in [2_0, 1_6]:
													lowerCamelCase_   : Union[str, Any]       =						'''over''' if self._hand_type == 2_0 else '''and'''
													return name + F""", {paira}s {join} {paira}s"""
								elif self._hand_type == 2_3:
													return name
								else:
													return name + F""", {high}"""

			def     UpperCAmelCase__	(self     ,				A ):
								# 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     UpperCAmelCase__	(self ):
								# 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 2_3 if sum(self._card_values ) == 6_0 else 2_2
													return 1_9
								elif self._is_five_high_straight() or self._is_straight():
													return 1_8
								return 1_4 + self._is_same_kind()

			def     UpperCAmelCase__	(self ):
								return len(self._card_suit ) == 1

			def     UpperCAmelCase__	(self ):
								# 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, 1_4]:
													if self._card_values[0] == 1_4:
																		# Remember, our list is sorted in reverse order
																		lowerCamelCase_   : Dict       =						self._card_values.pop(0 )
																		self._card_values.append(A )
													return True
								return False

			def     UpperCAmelCase__	(self ):
								for i in range(4 ):
													if self._card_values[i] - self._card_values[i + 1] != 1:
																		return False
								return True

			def     UpperCAmelCase__	(self ):
								# 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
								lowerCamelCase_   : str       =						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:
																							lowerCamelCase_   : Optional[Any]       =						self._card_values[i]
																							kind += 1
																		elif vala == self._card_values[i]:
																							kind += 2
																		elif not vala:
																							lowerCamelCase_   : int       =						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)
								lowerCamelCase_   : Union[str, Any]       =						kind + 2 if kind in [4, 5] else kind
								# first meaning first pair to compare in 'compare_with'
								lowerCamelCase_   : Union[str, Any]       =						max(A     ,				A )
								lowerCamelCase_   : Optional[int]       =						min(A     ,				A )
								# 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(A ) != 3:
													lowerCamelCase_, lowerCamelCase_   : Any       =						second, first
								lowerCamelCase_   : Optional[Any]       =						first
								lowerCamelCase_   : Tuple       =						second
								return kind

			def     UpperCAmelCase__	(self ):
								# Internal representation of hand as a list of card values and
								# a set of card suit
								lowerCamelCase_   : dict       =						{"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
								lowerCamelCase_   : int       =						self._hand.translate(str.maketrans(A ) ).split()
								lowerCamelCase_   : Union[str, Any]       =						[int(card[:-1] ) for card in new_hand]
								lowerCamelCase_   : str       =						{card[-1] for card in new_hand}
								return sorted(A     ,				reverse=A ), card_suit

			def __repr__(self ):
								return F"""{self.__class__}(\"{self._hand}\")"""

			def __str__(self ):
								return self._hand

			def __eq__(self     ,				A ):
								if isinstance(A     ,				A ):
													return self.compare_with(A ) == "Tie"
								return NotImplemented

			def __lt__(self     ,				A ):
								if isinstance(A     ,				A ):
													return self.compare_with(A ) == "Loss"
								return NotImplemented

			def __le__(self     ,				A ):
								if isinstance(A     ,				A ):
													return self < other or self == other
								return NotImplemented

			def __gt__(self     ,				A ):
								if isinstance(A     ,				A ):
													return not self < other and self != other
								return NotImplemented

			def __ge__(self     ,				A ):
								if isinstance(A     ,				A ):
													return not self < other
								return NotImplemented






			def __hash__(self ):
								return object.__hash__(self )




def lowercase_		(				)       ->							int:
					'''simple docstring'''

					lowerCamelCase_   : Dict       =						0
					lowerCamelCase_   : Any       =						os.path.abspath(os.path.dirname(_lowercase			)			)
					lowerCamelCase_   : Optional[int]       =						os.path.join(_lowercase     ,    '''poker_hands.txt'''			)
					with open(_lowercase			) as file_hand:
										for line in file_hand:
															lowerCamelCase_   : List[Any]       =						line[:14].strip()
															lowerCamelCase_   : int       =						line[15:].strip()
															lowerCamelCase_, lowerCamelCase_   : Any       =						PokerHand(_lowercase			), PokerHand(_lowercase			)
															lowerCamelCase_   : Dict       =						player.compare_with(_lowercase			)
															if output == "Win":
																				answer += 1
					return answer


if __name__ == "__main__":
					solution()




'''simple docstring'''


import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class 		__lowercase			(					_lowercase ,       unittest.TestCase      ):
			lowerCamelCase     :						List[str]		 =     KandinskyPipeline
			lowerCamelCase     :						List[str]		 =     [
			    "prompt",
			    "image_embeds",
			    "negative_image_embeds",
			]
			lowerCamelCase     :						str		 =     ["prompt", "negative_prompt", "image_embeds", "negative_image_embeds"]
			lowerCamelCase     :						Dict		 =     [
			    "generator",
			    "height",
			    "width",
			    "latents",
			    "guidance_scale",
			    "negative_prompt",
			    "num_inference_steps",
			    "return_dict",
			    "guidance_scale",
			    "num_images_per_prompt",
			    "output_type",
			    "return_dict",
			]
			lowerCamelCase     :						Union[str, Any]		 =     False

			@property
			def     UpperCAmelCase__	(self ):
								return 3_2

			@property
			def     UpperCAmelCase__	(self ):
								return 3_2

			@property
			def     UpperCAmelCase__	(self ):
								return self.time_input_dim

			@property
			def     UpperCAmelCase__	(self ):
								return self.time_input_dim * 4

			@property
			def     UpperCAmelCase__	(self ):
								return 1_0_0

			@property
			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : int       =						XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base''' )
								return tokenizer

			@property
			def     UpperCAmelCase__	(self ):
								torch.manual_seed(0 )
								lowerCamelCase_   : Any       =						MCLIPConfig(
								    numDims=self.cross_attention_dim     ,				transformerDimensions=self.text_embedder_hidden_size     ,				hidden_size=self.text_embedder_hidden_size     ,				intermediate_size=3_7     ,				num_attention_heads=4     ,				num_hidden_layers=5     ,				vocab_size=1_0_0_5     ,				)

								lowerCamelCase_   : Union[str, Any]       =						MultilingualCLIP(A )
								lowerCamelCase_   : Dict       =						text_encoder.eval()

								return text_encoder

			@property
			def     UpperCAmelCase__	(self ):
								torch.manual_seed(0 )

								lowerCamelCase_   : Dict       =						{
								    '''in_channels''': 4,
								    # Out channels is double in channels because predicts mean and variance
								    '''out_channels''': 8,
								    '''addition_embed_type''': '''text_image''',
								    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
								    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
								    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
								    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
								    '''layers_per_block''': 1,
								    '''encoder_hid_dim''': self.text_embedder_hidden_size,
								    '''encoder_hid_dim_type''': '''text_image_proj''',
								    '''cross_attention_dim''': self.cross_attention_dim,
								    '''attention_head_dim''': 4,
								    '''resnet_time_scale_shift''': '''scale_shift''',
								    '''class_embed_type''': None,
								}

								lowerCamelCase_   : Union[str, Any]       =						UNetaDConditionModel(**A )
								return model

			@property
			def     UpperCAmelCase__	(self ):
								return {
								    "block_out_channels": [3_2, 6_4],
								    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
								    "in_channels": 3,
								    "latent_channels": 4,
								    "layers_per_block": 1,
								    "norm_num_groups": 8,
								    "norm_type": "spatial",
								    "num_vq_embeddings": 1_2,
								    "out_channels": 3,
								    "up_block_types": [
								        "AttnUpDecoderBlock2D",
								        "UpDecoderBlock2D",
								    ],
								    "vq_embed_dim": 4,
								}

			@property
			def     UpperCAmelCase__	(self ):
								torch.manual_seed(0 )
								lowerCamelCase_   : Dict       =						VQModel(**self.dummy_movq_kwargs )
								return model

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : List[str]       =						self.dummy_text_encoder
								lowerCamelCase_   : Tuple       =						self.dummy_tokenizer
								lowerCamelCase_   : int       =						self.dummy_unet
								lowerCamelCase_   : str       =						self.dummy_movq

								lowerCamelCase_   : str       =						DDIMScheduler(
								    num_train_timesteps=1_0_0_0     ,				beta_schedule='''linear'''     ,				beta_start=0.0_00_85     ,				beta_end=0.0_12     ,				clip_sample=A     ,				set_alpha_to_one=A     ,				steps_offset=1     ,				prediction_type='''epsilon'''     ,				thresholding=A     ,				)

								lowerCamelCase_   : int       =						{
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''movq''': movq,
								}
								return components

			def     UpperCAmelCase__	(self     ,				A     ,				A=0 ):
								lowerCamelCase_   : Union[str, Any]       =						floats_tensor((1, self.cross_attention_dim)     ,				rng=random.Random(A ) ).to(A )
								lowerCamelCase_   : List[Any]       =						floats_tensor((1, self.cross_attention_dim)     ,				rng=random.Random(seed + 1 ) ).to(A )
								if str(A ).startswith('''mps''' ):
													lowerCamelCase_   : List[str]       =						torch.manual_seed(A )
								else:
													lowerCamelCase_   : Optional[Any]       =						torch.Generator(device=A ).manual_seed(A )
								lowerCamelCase_   : Any       =						{
								    '''prompt''': '''horse''',
								    '''image_embeds''': image_embeds,
								    '''negative_image_embeds''': negative_image_embeds,
								    '''generator''': generator,
								    '''height''': 6_4,
								    '''width''': 6_4,
								    '''guidance_scale''': 4.0,
								    '''num_inference_steps''': 2,
								    '''output_type''': '''np''',
								}
								return inputs






			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : int       =						'''cpu'''

								lowerCamelCase_   : Optional[Any]       =						self.get_dummy_components()

								lowerCamelCase_   : Tuple       =						self.pipeline_class(**A )
								lowerCamelCase_   : List[str]       =						pipe.to(A )

								pipe.set_progress_bar_config(disable=A )

								lowerCamelCase_   : Optional[Any]       =						pipe(**self.get_dummy_inputs(A ) )
								lowerCamelCase_   : int       =						output.images

								lowerCamelCase_   : List[Any]       =						pipe(
								    **self.get_dummy_inputs(A )     ,				return_dict=A     ,				)[0]

								lowerCamelCase_   : List[Any]       =						image[0, -3:, -3:, -1]
								lowerCamelCase_   : List[Any]       =						image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (1, 6_4, 6_4, 3)

								lowerCamelCase_   : int       =						np.array(
								    [0.32_86_63, 1.0, 0.23_21_68_73, 1.0, 0.92_71_75_64, 0.4_63_90_46, 0.96_89_47_77, 0.31_71_33_78, 0.6_29_39_53] )

								assert (
								    np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
								), F""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
								assert (
								    np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2
								), F""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""

@slow
@require_torch_gpu
class 		__lowercase			(					unittest.TestCase      ):

			def     UpperCAmelCase__	(self ):
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : Tuple       =						load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
								    '''/kandinsky/kandinsky_text2img_cat_fp16.npy''' )

								lowerCamelCase_   : str       =						KandinskyPriorPipeline.from_pretrained(
								    '''kandinsky-community/kandinsky-2-1-prior'''     ,				torch_dtype=torch.floataa )
								pipe_prior.to(A )

								lowerCamelCase_   : List[Any]       =						KandinskyPipeline.from_pretrained('''kandinsky-community/kandinsky-2-1'''     ,				torch_dtype=torch.floataa )
								lowerCamelCase_   : Tuple       =						pipeline.to(A )
								pipeline.set_progress_bar_config(disable=A )

								lowerCamelCase_   : List[str]       =						'''red cat, 4k photo'''

								lowerCamelCase_   : Optional[Any]       =						torch.Generator(device='''cuda''' ).manual_seed(0 )
								lowerCamelCase_, lowerCamelCase_   : Any       =						pipe_prior(
								    A     ,				generator=A     ,				num_inference_steps=5     ,				negative_prompt=''''''     ,				).to_tuple()

								lowerCamelCase_   : Optional[Any]       =						torch.Generator(device='''cuda''' ).manual_seed(0 )
								lowerCamelCase_   : Optional[Any]       =						pipeline(
								    A     ,				image_embeds=A     ,				negative_image_embeds=A     ,				generator=A     ,				num_inference_steps=1_0_0     ,				output_type='''np'''     ,				)

								lowerCamelCase_   : Union[str, Any]       =						output.images[0]

								assert image.shape == (5_1_2, 5_1_2, 3)

								assert_mean_pixel_difference(A     ,				A )


