

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

import pytest

from .sola import PokerHand

_lowerCAmelCase  :      Dict			 =(
    "4S 3H 2C 7S 5H",
    "9D 8H 2C 6S 7H",
    "2D 6D 9D TH 7D",
    "TC 8C 2S JH 6C",
    "JH 8S TH AH QH",
    "TS KS 5S 9S AC",
    "KD 6S 9D TH AD",
    "KS 8D 4D 9S 4S",  # pair
    "8C 4S KH JS 4D",  # pair
    "QH 8H KD JH 8S",  # pair
    "KC 4H KS 2H 8D",  # pair
    "KD 4S KC 3H 8S",  # pair
    "AH 8S AS KC JH",  # pair
    "3H 4C 4H 3S 2H",  # 2 pairs
    "5S 5D 2C KH KH",  # 2 pairs
    "3C KH 5D 5S KH",  # 2 pairs
    "AS 3C KH AD KH",  # 2 pairs
    "7C 7S 3S 7H 5S",  # 3 of a kind
    "7C 7S KH 2H 7H",  # 3 of a kind
    "AC KH QH AH AS",  # 3 of a kind
    "2H 4D 3C AS 5S",  # straight (low ace)
    "3C 5C 4C 2C 6H",  # straight
    "6S 8S 7S 5H 9H",  # straight
    "JS QS 9H TS KH",  # straight
    "QC KH TS JS AH",  # straight (high ace)
    "8C 9C 5C 3C TC",  # flush
    "3S 8S 9S 5S KS",  # flush
    "4C 5C 9C 8C KC",  # flush
    "JH 8H AH KH QH",  # flush
    "3D 2H 3H 2C 2D",  # full house
    "2H 2C 3S 3H 3D",  # full house
    "KH KC 3S 3H 3D",  # full house
    "JC 6H JS JD JH",  # 4 of a kind
    "JC 7H JS JD JH",  # 4 of a kind
    "JC KH JS JD JH",  # 4 of a kind
    "2S AS 4S 5S 3S",  # straight flush (low ace)
    "2D 6D 3D 4D 5D",  # straight flush
    "5C 6C 3C 7C 4C",  # straight flush
    "JH 9H TH KH QH",  # straight flush
    "JH AH TH KH QH",  # royal flush (high ace straight flush)
)

_lowerCAmelCase  :      Dict			 =(
    ("2H 3H 4H 5H 6H", "KS AS TS QS JS", "Loss"),
    ("2H 3H 4H 5H 6H", "AS AD AC AH JD", "Win"),
    ("AS AH 2H AD AC", "JS JD JC JH 3D", "Win"),
    ("2S AH 2H AS AC", "JS JD JC JH AD", "Loss"),
    ("2S AH 2H AS AC", "2H 3H 5H 6H 7H", "Win"),
    ("AS 3S 4S 8S 2S", "2H 3H 5H 6H 7H", "Win"),
    ("2H 3H 5H 6H 7H", "2S 3H 4H 5S 6C", "Win"),
    ("2S 3H 4H 5S 6C", "3D 4C 5H 6H 2S", "Tie"),
    ("2S 3H 4H 5S 6C", "AH AC 5H 6H AS", "Win"),
    ("2S 2H 4H 5S 4C", "AH AC 5H 6H AS", "Loss"),
    ("2S 2H 4H 5S 4C", "AH AC 5H 6H 7S", "Win"),
    ("6S AD 7H 4S AS", "AH AC 5H 6H 7S", "Loss"),
    ("2S AH 4H 5S KC", "AH AC 5H 6H 7S", "Loss"),
    ("2S 3H 6H 7S 9C", "7H 3C TH 6H 9S", "Loss"),
    ("4S 5H 6H TS AC", "3S 5H 6H TS AC", "Win"),
    ("2S AH 4H 5S 6C", "AD 4C 5H 6H 2C", "Tie"),
    ("AS AH 3H AD AC", "AS AH 2H AD AC", "Win"),
    ("AH AC 5H 5C QS", "AH AC 5H 5C KS", "Loss"),
    ("AH AC 5H 5C QS", "KH KC 5H 5C QS", "Win"),
    ("7C 7S KH 2H 7H", "3C 3S AH 2H 3H", "Win"),
    ("3C 3S AH 2H 3H", "7C 7S KH 2H 7H", "Loss"),
    ("6H 5H 4H 3H 2H", "5H 4H 3H 2H AH", "Win"),
    ("5H 4H 3H 2H AH", "5H 4H 3H 2H AH", "Tie"),
    ("5H 4H 3H 2H AH", "6H 5H 4H 3H 2H", "Loss"),
    ("AH AD KS KC AC", "AH KD KH AC KC", "Win"),
    ("2H 4D 3C AS 5S", "2H 4D 3C 6S 5S", "Loss"),
    ("2H 3S 3C 3H 2S", "3S 3C 2S 2H 2D", "Win"),
    ("4D 6D 5D 2D JH", "3S 8S 3H TC KH", "Loss"),
    ("4S 6C 8S 3S 7S", "AD KS 2D 7D 7C", "Loss"),
    ("6S 4C 7H 8C 3H", "5H JC AH 9D 9C", "Loss"),
    ("9D 9H JH TC QH", "3C 2S JS 5C 7H", "Win"),
    ("2H TC 8S AD 9S", "4H TS 7H 2C 5C", "Win"),
    ("9D 3S 2C 7S 7C", "JC TD 3C TC 9H", "Loss"),
)

_lowerCAmelCase  :      Any			 =(
    ("2H 3H 4H 5H 6H", True),
    ("AS AH 2H AD AC", False),
    ("2H 3H 5H 6H 7H", True),
    ("KS AS TS QS JS", True),
    ("8H 9H QS JS TH", False),
    ("AS 3S 4S 8S 2S", True),
)

_lowerCAmelCase  :      Union[str, Any]			 =(
    ("2H 3H 4H 5H 6H", True),
    ("AS AH 2H AD AC", False),
    ("2H 3H 5H 6H 7H", False),
    ("KS AS TS QS JS", True),
    ("8H 9H QS JS TH", True),
)

_lowerCAmelCase  :      Optional[int]			 =(
    ("2H 4D 3C AS 5S", True, [5, 4, 3, 2, 14]),
    ("2H 5D 3C AS 5S", False, [14, 5, 5, 3, 2]),
    ("JH QD KC AS TS", False, [14, 13, 12, 11, 10]),
    ("9D 3S 2C 7S 7C", False, [9, 7, 7, 3, 2]),
)

_lowerCAmelCase  :      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),
)

_lowerCAmelCase  :      Optional[Any]			 =(
    ("JH AH TH KH QH", 23),
    ("JH 9H TH KH QH", 22),
    ("JC KH JS JD JH", 21),
    ("KH KC 3S 3H 3D", 20),
    ("8C 9C 5C 3C TC", 19),
    ("JS QS 9H TS KH", 18),
    ("7C 7S KH 2H 7H", 17),
    ("3C KH 5D 5S KH", 16),
    ("QH 8H KD JH 8S", 15),
    ("2D 6D 9D TH 7D", 14),
)



def 			_A	(      ):
	UpperCAmelCase__							,						UpperCAmelCase__:	List[str]									= randrange(len(__lowerCamelCase      )      ), randrange(len(__lowerCamelCase      )      )
	UpperCAmelCase__:	Union[str, Any]									= ["Loss", "Tie", "Win"][(play >= oppo) + (play > oppo)]
	UpperCAmelCase__							,						UpperCAmelCase__:	Optional[Any]									= SORTED_HANDS[play], SORTED_HANDS[oppo]
	return hand, other, expected



def 			_A	(      SCREAMING_SNAKE_CASE = 1_0_0      ):
	return (generate_random_hand() for _ in range(__lowerCamelCase      ))



@pytest.mark.parametrize("hand, expected"	,__lowerCamelCase      )
def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      ):
	assert PokerHand(__lowerCamelCase      )._is_flush() == expected



@pytest.mark.parametrize("hand, expected"	,__lowerCamelCase      )
def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      ):
	assert PokerHand(__lowerCamelCase      )._is_straight() == expected



@pytest.mark.parametrize("hand, expected, card_values"	,__lowerCamelCase      )
def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      ):
	UpperCAmelCase__:	List[str]									= PokerHand(__lowerCamelCase      )
	assert player._is_five_high_straight() == expected
	assert player._card_values == card_values



@pytest.mark.parametrize("hand, expected"	,__lowerCamelCase      )
def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      ):
	assert PokerHand(__lowerCamelCase      )._is_same_kind() == expected



@pytest.mark.parametrize("hand, expected"	,__lowerCamelCase      )
def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      ):
	assert PokerHand(__lowerCamelCase      )._hand_type == expected



@pytest.mark.parametrize("hand, other, expected"	,__lowerCamelCase      )
def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      ):
	assert PokerHand(__lowerCamelCase      ).compare_with(PokerHand(__lowerCamelCase      )      ) == expected



@pytest.mark.parametrize("hand, other, expected"	,generate_random_hands()      )
def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      ):
	assert PokerHand(__lowerCamelCase      ).compare_with(PokerHand(__lowerCamelCase      )      ) == expected



def 			_A	(      ):
	UpperCAmelCase__:	Optional[Any]									= [PokerHand(__lowerCamelCase      ) for hand in SORTED_HANDS]
	UpperCAmelCase__:	Dict									= poker_hands.copy()
	shuffle(__lowerCamelCase      )
	UpperCAmelCase__:	str									= chain(sorted(__lowerCamelCase      )      )
	for index, hand in enumerate(__lowerCamelCase      ):
		assert hand == poker_hands[index]



def 			_A	(      ):
	# Test that five high straights are compared correctly.
	UpperCAmelCase__:	Dict									= [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 			_A	(      ):
	# Multiple calls to five_high_straight function should still return True
	# and shouldn't mutate the list in every call other than the first.
	UpperCAmelCase__:	Dict									= PokerHand("2C 4S AS 3D 5C"      )
	UpperCAmelCase__:	Dict									= True
	UpperCAmelCase__:	Any									= [5, 4, 3, 2, 1_4]
	for _ in range(1_0      ):
		assert pokerhand._is_five_high_straight() == expected
		assert pokerhand._card_values == expected_card_values



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





import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





def 						__A						(      __lowerCamelCase       ) ->			Optional[int]:
	a									=				[tensor.shape for tensor in tensor_list]
	return all(shape == shapes[0] for shape in shapes[1:]       )

class 						__lowerCAmelCase      (      __magic_name__ ,			__magic_name__ ,			__magic_name__ ,			unittest.TestCase					):
							UpperCamelCase__   	=    StableDiffusionLatentUpscalePipeline
							UpperCamelCase__   	=    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
							    '''height''',
							    '''width''',
							    '''cross_attention_kwargs''',
							    '''negative_prompt_embeds''',
							    '''prompt_embeds''',
							}
							UpperCamelCase__   	=    PipelineTesterMixin.required_optional_params - {'''num_images_per_prompt'''}
							UpperCamelCase__   	=    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
							UpperCamelCase__   	=    frozenset(
							    []					)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
							UpperCamelCase__   	=    frozenset([]					)

							UpperCamelCase__   	=    True
							@property
							def  lowerCamelCase__				(		self		:List[str]							):







								'''simple docstring'''







								a									=				1
								a									=				4
								a									=				(16, 16)

								a									=				floats_tensor((batch_size, num_channels) + sizes						, rng=random.Random(0							)							).to(__magic_name__							)
								return image
							def  lowerCamelCase__				(		self		:Any							):







								'''simple docstring'''







								torch.manual_seed(0							)
								a									=				UNetaDConditionModel(
								    act_fn="""gelu"""						, attention_head_dim=8						, norm_num_groups=__magic_name__						, block_out_channels=[32, 32, 64, 64]						, time_cond_proj_dim=160						, conv_in_kernel=1						, conv_out_kernel=1						, cross_attention_dim=32						, down_block_types=(
								        """KDownBlock2D""",
								        """KCrossAttnDownBlock2D""",
								        """KCrossAttnDownBlock2D""",
								        """KCrossAttnDownBlock2D""",
								    )						, in_channels=8						, mid_block_type=__magic_name__						, only_cross_attention=__magic_name__						, out_channels=5						, resnet_time_scale_shift="""scale_shift"""						, time_embedding_type="""fourier"""						, timestep_post_act="""gelu"""						, up_block_types=("""KCrossAttnUpBlock2D""", """KCrossAttnUpBlock2D""", """KCrossAttnUpBlock2D""", """KUpBlock2D""")						, )
								a									=				AutoencoderKL(
								    block_out_channels=[32, 32, 64, 64]						, in_channels=3						, out_channels=3						, down_block_types=[
								        """DownEncoderBlock2D""",
								        """DownEncoderBlock2D""",
								        """DownEncoderBlock2D""",
								        """DownEncoderBlock2D""",
								    ]						, up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D""", """UpDecoderBlock2D""", """UpDecoderBlock2D"""]						, latent_channels=4						, )
								a									=				EulerDiscreteScheduler(prediction_type="""sample"""							)
								a									=				CLIPTextConfig(
								    bos_token_id=0						, eos_token_id=2						, hidden_size=32						, intermediate_size=37						, layer_norm_eps=1E-0_5						, num_attention_heads=4						, num_hidden_layers=5						, pad_token_id=1						, vocab_size=1000						, hidden_act="""quick_gelu"""						, projection_dim=512						, )
								a									=				CLIPTextModel(__magic_name__							)
								a									=				CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

								a									=				{
								    """unet""": model.eval(),
								    """vae""": vae.eval(),
								    """scheduler""": scheduler,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								}

								return components
							def  lowerCamelCase__				(		self		:Optional[int]						, __magic_name__		:Tuple						, __magic_name__		:Optional[int]=0							):







								'''simple docstring'''







								if str(__magic_name__							).startswith("""mps"""							):
									a									=				torch.manual_seed(__magic_name__							)
								else:
									a									=				torch.Generator(device=__magic_name__							).manual_seed(__magic_name__							)
								a									=				{
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """image""": self.dummy_image.cpu(),
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """output_type""": """numpy""",
								}
								return inputs
							def  lowerCamelCase__				(		self		:Optional[int]							):







								'''simple docstring'''







								a									=				"""cpu"""

								a									=				self.get_dummy_components()
								a									=				self.pipeline_class(**__magic_name__							)
								pipe.to(__magic_name__							)
								pipe.set_progress_bar_config(disable=__magic_name__							)

								a									=				self.get_dummy_inputs(__magic_name__							)
								a									=				pipe(**__magic_name__							).images
								a									=				image[0, -3:, -3:, -1]

								self.assertEqual(image.shape						, (1, 256, 256, 3)							)
								a									=				np.array(
								    [0.47222412, 0.41921633, 0.44717434, 0.46874192, 0.42588258, 0.46150726, 0.4677534, 0.45583832, 0.48579055]							)
								a									=				np.abs(image_slice.flatten() - expected_slice							).max()
								self.assertLessEqual(__magic_name__						, 1E-3							)
							def  lowerCamelCase__				(		self		:Any							):







								'''simple docstring'''







								super().test_attention_slicing_forward_pass(expected_max_diff=7E-3							)
							def  lowerCamelCase__				(		self		:Optional[int]							):







								'''simple docstring'''







								super().test_cpu_offload_forward_pass(expected_max_diff=3E-3							)
							def  lowerCamelCase__				(		self		:Dict							):







								'''simple docstring'''







								super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3							)
							def  lowerCamelCase__				(		self		:List[Any]							):







								'''simple docstring'''







								super().test_inference_batch_single_identical(expected_max_diff=7E-3							)
							def  lowerCamelCase__				(		self		:Optional[int]							):







								'''simple docstring'''







								super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3E-3							)
							def  lowerCamelCase__				(		self		:str							):







								'''simple docstring'''







								super().test_save_load_local(expected_max_difference=3E-3							)
							def  lowerCamelCase__				(		self		:Tuple							):







								'''simple docstring'''







								super().test_save_load_optional_components(expected_max_difference=3E-3							)





							def  lowerCamelCase__				(		self		:List[str]							):







								'''simple docstring'''







								a									=				[
								    """DDIMScheduler""",
								    """DDPMScheduler""",
								    """PNDMScheduler""",
								    """HeunDiscreteScheduler""",
								    """EulerAncestralDiscreteScheduler""",
								    """KDPM2DiscreteScheduler""",
								    """KDPM2AncestralDiscreteScheduler""",
								    """DPMSolverSDEScheduler""",
								]
								a									=				self.get_dummy_components()
								a									=				self.pipeline_class(**__magic_name__							)

								# make sure that PNDM does not need warm-up
								pipe.scheduler.register_to_config(skip_prk_steps=__magic_name__							)

								pipe.to(__magic_name__							)
								pipe.set_progress_bar_config(disable=__magic_name__							)
								a									=				self.get_dummy_inputs(__magic_name__							)
								a									=				2

								a									=				[]
								for scheduler_enum in KarrasDiffusionSchedulers:
									if scheduler_enum.name in skip_schedulers:
										# no sigma schedulers are not supported
										# no schedulers
										continue

									a									=				getattr(__magic_name__						, scheduler_enum.name							)
									a									=				scheduler_cls.from_config(pipe.scheduler.config							)
									a									=				pipe(**__magic_name__							)[0]
									outputs.append(__magic_name__							)

								assert check_same_shape(__magic_name__							)







@require_torch_gpu
@slow
class 						__lowerCAmelCase      (      unittest.TestCase					):
							def  lowerCamelCase__				(		self		:List[str]							):







								'''simple docstring'''







								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()
							def  lowerCamelCase__				(		self		:List[Any]							):







								'''simple docstring'''







								a									=				torch.manual_seed(33							)

								a									=				StableDiffusionPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4"""						, torch_dtype=torch.floataa							)
								pipe.to("""cuda"""							)

								a									=				StableDiffusionLatentUpscalePipeline.from_pretrained(
								    """stabilityai/sd-x2-latent-upscaler"""						, torch_dtype=torch.floataa							)
								upscaler.to("""cuda"""							)

								a									=				"""a photo of an astronaut high resolution, unreal engine, ultra realistic"""

								a									=				pipe(__magic_name__						, generator=__magic_name__						, output_type="""latent"""							).images

								a									=				upscaler(
								    prompt=__magic_name__						, image=__magic_name__						, num_inference_steps=20						, guidance_scale=0						, generator=__magic_name__						, output_type="""np"""						, ).images[0]

								a									=				load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy"""							)
								assert np.abs((expected_image - image).mean()							) < 5E-2





							def  lowerCamelCase__				(		self		:Optional[Any]							):







								'''simple docstring'''







								a									=				torch.manual_seed(33							)

								a									=				StableDiffusionLatentUpscalePipeline.from_pretrained(
								    """stabilityai/sd-x2-latent-upscaler"""						, torch_dtype=torch.floataa							)
								upscaler.to("""cuda"""							)

								a									=				"""the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas"""

								a									=				load_image(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png"""							)

								a									=				upscaler(
								    prompt=__magic_name__						, image=__magic_name__						, num_inference_steps=20						, guidance_scale=0						, generator=__magic_name__						, output_type="""np"""						, ).images[0]

								a									=				load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy"""							)
								assert np.abs((expected_image - image).max()							) < 5E-2

