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

import pytest

from .sola import PokerHand

lowercase_     :   Optional[int]				=				(
    '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_     :   List[Any]				=				(
    ('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_     :   List[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),
)

lowercase_     :   Dict				=				(
    ('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_     :   Optional[int]				=				(
    ('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_     :   Union[str, Any]				=				(
    ('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_     :   List[Any]				=				(
    ('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 			A__      (	):
 SCREAMING_SNAKE_CASE__:   Optional[Any]=      randrange(len(_lowerCamelCase      )      ), randrange(len(_lowerCamelCase      )      )
 SCREAMING_SNAKE_CASE__:   List[Any]=      ['Loss', 'Tie', 'Win'][(play >= oppo) + (play > oppo)]
 SCREAMING_SNAKE_CASE__:   int=      SORTED_HANDS[play], SORTED_HANDS[oppo]
 return hand, other, expected







def 			A__      (	snake_case_ :		Dict = 100      ):
 return (generate_random_hand() for _ in range(_lowerCamelCase      ))







@pytest.mark.parametrize('''hand, expected'''       ,				_lowerCamelCase      )
def 			A__      (	snake_case_ :		List[str]       ,				snake_case_ :		str      ):
 assert PokerHand(_lowerCamelCase      )._is_flush() == expected







@pytest.mark.parametrize('''hand, expected'''       ,				_lowerCamelCase      )
def 			A__      (	snake_case_ :		Optional[Any]       ,				snake_case_ :		Union[str, Any]      ):
 assert PokerHand(_lowerCamelCase      )._is_straight() == expected







@pytest.mark.parametrize('''hand, expected, card_values'''       ,				_lowerCamelCase      )
def 			A__      (	snake_case_ :		str       ,				snake_case_ :		List[Any]       ,				snake_case_ :		List[Any]      ):
 SCREAMING_SNAKE_CASE__:   int=      PokerHand(_lowerCamelCase      )
 assert player._is_five_high_straight() == expected
 assert player._card_values == card_values







@pytest.mark.parametrize('''hand, expected'''       ,				_lowerCamelCase      )
def 			A__      (	snake_case_ :		Union[str, Any]       ,				snake_case_ :		List[Any]      ):
 assert PokerHand(_lowerCamelCase      )._is_same_kind() == expected







@pytest.mark.parametrize('''hand, expected'''       ,				_lowerCamelCase      )
def 			A__      (	snake_case_ :		Optional[Any]       ,				snake_case_ :		int      ):
 assert PokerHand(_lowerCamelCase      )._hand_type == expected







@pytest.mark.parametrize('''hand, other, expected'''       ,				_lowerCamelCase      )
def 			A__      (	snake_case_ :		Optional[Any]       ,				snake_case_ :		List[str]       ,				snake_case_ :		List[str]      ):
 assert PokerHand(_lowerCamelCase      ).compare_with(PokerHand(_lowerCamelCase      )      ) == expected







@pytest.mark.parametrize('''hand, other, expected'''       ,				generate_random_hands()      )
def 			A__      (	snake_case_ :		Optional[Any]       ,				snake_case_ :		Tuple       ,				snake_case_ :		Tuple      ):
 assert PokerHand(_lowerCamelCase      ).compare_with(PokerHand(_lowerCamelCase      )      ) == expected







def 			A__      (	):
 SCREAMING_SNAKE_CASE__:   Optional[Any]=      [PokerHand(_lowerCamelCase      ) for hand in SORTED_HANDS]
 SCREAMING_SNAKE_CASE__:   List[str]=      poker_hands.copy()
 shuffle(_lowerCamelCase      )
 SCREAMING_SNAKE_CASE__:   int=      chain(sorted(_lowerCamelCase      )      )
 for index, hand in enumerate(_lowerCamelCase      ):
  assert hand == poker_hands[index]







def 			A__      (	):
 SCREAMING_SNAKE_CASE__:   Tuple=      [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__      (	):
 SCREAMING_SNAKE_CASE__:   Union[str, Any]=      PokerHand('''2C 4S AS 3D 5C'''      )
 SCREAMING_SNAKE_CASE__:   List[Any]=      True
 SCREAMING_SNAKE_CASE__:   Optional[int]=      [5, 4, 3, 2, 14]
 for _ in range(10      ):
  assert pokerhand._is_five_high_straight() == expected
  assert pokerhand._card_values == expected_card_values







def 			A__      (	):
 SCREAMING_SNAKE_CASE__:   List[str]=      0
 SCREAMING_SNAKE_CASE__:   Optional[Any]=      os.path.abspath(os.path.dirname(_lowerCamelCase      )      )
 SCREAMING_SNAKE_CASE__:   Optional[Any]=      os.path.join(_lowerCamelCase       ,				'''poker_hands.txt'''      )
 with open(_lowerCamelCase      ) as file_hand:
  for line in file_hand:
   SCREAMING_SNAKE_CASE__:   Dict=      line[:14].strip()
   SCREAMING_SNAKE_CASE__:   List[str]=      line[15:].strip()
   SCREAMING_SNAKE_CASE__:   List[str]=      PokerHand(_lowerCamelCase      ), PokerHand(_lowerCamelCase      )
   SCREAMING_SNAKE_CASE__:   Dict=      player.compare_with(_lowerCamelCase      )
   if output == "Win":
    answer += 1
 assert answer == 376


import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class 		_lowerCamelCase		(   UpperCamelCase_    ,     UpperCamelCase_    ,     UpperCamelCase_    ,     unittest.TestCase    ):
    __a  =      AltDiffusionPipeline
    __a  =      TEXT_TO_IMAGE_PARAMS
    __a  =      TEXT_TO_IMAGE_BATCH_PARAMS
    __a  =      TEXT_TO_IMAGE_IMAGE_PARAMS
    __a  =      TEXT_TO_IMAGE_IMAGE_PARAMS
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      UNetaDConditionModel(
         block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , )
     SCREAMING_SNAKE_CASE__:   Tuple=      DDIMScheduler(
         beta_start=0.00085 , beta_end=0.012 , beta_schedule='''scaled_linear''' , clip_sample=lowerCAmelCase , set_alpha_to_one=lowerCAmelCase , )
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      AutoencoderKL(
         block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , )

     # TODO: address the non-deterministic text encoder (fails for save-load tests)
     # torch.manual_seed(0)
     # text_encoder_config = RobertaSeriesConfig(
     #     hidden_size=32,
     #     project_dim=32,
     #     intermediate_size=37,
     #     layer_norm_eps=1e-05,
     #     num_attention_heads=4,
     #     num_hidden_layers=5,
     #     vocab_size=5002,
     # )
     # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Tuple=      CLIPTextConfig(
         bos_token_id=0 , eos_token_id=2 , hidden_size=32 , projection_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=5002 , )
     SCREAMING_SNAKE_CASE__:   List[Any]=      CLIPTextModel(lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      77

     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      {
         '''unet''': unet,
         '''scheduler''': scheduler,
         '''vae''': vae,
         '''text_encoder''': text_encoder,
         '''tokenizer''': tokenizer,
         '''safety_checker''': None,
         '''feature_extractor''': None,
     }
     return components
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase=0   )       ->					List[Any]:
     if str(lowerCAmelCase   ).startswith('''mps'''   ):
      SCREAMING_SNAKE_CASE__:   Any=      torch.manual_seed(lowerCAmelCase   )
     else:
      SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Any=      {
         '''prompt''': '''A painting of a squirrel eating a burger''',
         '''generator''': generator,
         '''num_inference_steps''': 2,
         '''guidance_scale''': 6.0,
         '''output_type''': '''numpy''',
     }
     return inputs
    def 						UpperCamelCase_				(  self   )       ->					List[str]:
     super().test_attention_slicing_forward_pass(expected_max_diff=3e-3   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     super().test_inference_batch_single_identical(expected_max_diff=3e-3   )
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__:   Tuple=      self.get_dummy_components()
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      RobertaSeriesConfig(
         hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , vocab_size=5002 , )
     # TODO: remove after fixing the non-deterministic text encoder
     SCREAMING_SNAKE_CASE__:   List[str]=      RobertaSeriesModelWithTransformation(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      text_encoder

     SCREAMING_SNAKE_CASE__:   List[Any]=      AltDiffusionPipeline(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   str=      self.get_dummy_inputs(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Dict=      '''A photo of an astronaut'''
     SCREAMING_SNAKE_CASE__:   Any=      alt_pipe(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      output.images
     SCREAMING_SNAKE_CASE__:   Tuple=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__:   Any=      np.array(
         [0.5748162, 0.60447145, 0.48821217, 0.50100636, 0.5431185, 0.45763683, 0.49657696, 0.48132733, 0.47573093]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2



    def 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     SCREAMING_SNAKE_CASE__:   List[str]=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__:   Any=      self.get_dummy_components()
     SCREAMING_SNAKE_CASE__:   List[str]=      PNDMScheduler(skip_prk_steps=lowerCAmelCase   )
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Tuple=      RobertaSeriesConfig(
         hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , vocab_size=5002 , )
     # TODO: remove after fixing the non-deterministic text encoder
     SCREAMING_SNAKE_CASE__:   str=      RobertaSeriesModelWithTransformation(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      text_encoder
     SCREAMING_SNAKE_CASE__:   Any=      AltDiffusionPipeline(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      self.get_dummy_inputs(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      alt_pipe(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      output.images
     SCREAMING_SNAKE_CASE__:   Tuple=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__:   List[Any]=      np.array(
         [0.51605093, 0.5707241, 0.47365507, 0.50578886, 0.5633877, 0.4642503, 0.5182081, 0.48763484, 0.49084237]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2






@slow
@require_torch_gpu
class 		_lowerCamelCase		(   unittest.TestCase    ):
    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()
    def 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     # make sure here that pndm scheduler skips prk
     SCREAMING_SNAKE_CASE__:   Any=      AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion''' , safety_checker=lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Dict=      '''A painting of a squirrel eating a burger'''
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Tuple=      alt_pipe([prompt] , generator=lowerCAmelCase , guidance_scale=6.0 , num_inference_steps=20 , output_type='''np'''   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      output.images

     SCREAMING_SNAKE_CASE__:   Dict=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     SCREAMING_SNAKE_CASE__:   Optional[int]=      np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2



    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     SCREAMING_SNAKE_CASE__:   List[Any]=      DDIMScheduler.from_pretrained('''BAAI/AltDiffusion''' , subfolder='''scheduler'''   )

     SCREAMING_SNAKE_CASE__:   List[str]=      AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion''' , scheduler=lowerCAmelCase , safety_checker=lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Optional[Any]=      '''A painting of a squirrel eating a burger'''
     SCREAMING_SNAKE_CASE__:   Any=      torch.manual_seed(0   )

     SCREAMING_SNAKE_CASE__:   str=      alt_pipe([prompt] , generator=lowerCAmelCase , num_inference_steps=2 , output_type='''numpy'''   )
     SCREAMING_SNAKE_CASE__:   List[str]=      output.images

     SCREAMING_SNAKE_CASE__:   Dict=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2

