



'''simple docstring'''





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, 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]),
)

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", 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 lowerCAmelCase    ():



     """simple docstring"""



     _a    ,       _a           =    randrange(len(__A)), randrange(len(__A))
     _a           =    ['''Loss''', '''Tie''', '''Win'''][(play >= oppo) + (play > oppo)]
     _a    ,       _a           =    SORTED_HANDS[play], SORTED_HANDS[oppo]
     return hand, other, expected




def lowerCAmelCase    (__A = 100):



     """simple docstring"""



     return (generate_random_hand() for _ in range(__A))




@pytest.mark.parametrize('''hand, expected'''    ,      __A)
def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     assert PokerHand(__A)._is_flush() == expected




@pytest.mark.parametrize('''hand, expected'''    ,      __A)
def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     assert PokerHand(__A)._is_straight() == expected




@pytest.mark.parametrize('''hand, expected, card_values'''    ,      __A)
def lowerCAmelCase    (__A    ,      __A    ,      __A):



     """simple docstring"""



     _a           =    PokerHand(__A)
     assert player._is_five_high_straight() == expected
     assert player._card_values == card_values




@pytest.mark.parametrize('''hand, expected'''    ,      __A)
def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     assert PokerHand(__A)._is_same_kind() == expected




@pytest.mark.parametrize('''hand, expected'''    ,      __A)
def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     assert PokerHand(__A)._hand_type == expected




@pytest.mark.parametrize('''hand, other, expected'''    ,      __A)
def lowerCAmelCase    (__A    ,      __A    ,      __A):



     """simple docstring"""



     assert PokerHand(__A).compare_with(PokerHand(__A)) == expected




@pytest.mark.parametrize('''hand, other, expected'''    ,      generate_random_hands())
def lowerCAmelCase    (__A    ,      __A    ,      __A):



     """simple docstring"""



     assert PokerHand(__A).compare_with(PokerHand(__A)) == expected




def lowerCAmelCase    ():



     """simple docstring"""



     _a           =    [PokerHand(__A) for hand in SORTED_HANDS]
     _a           =    poker_hands.copy()
     shuffle(__A)
     _a           =    chain(sorted(__A))
     for index, hand in enumerate(__A):
          assert hand == poker_hands[index]




def lowerCAmelCase    ():



     """simple docstring"""



     _a           =    [PokerHand('''2D AC 3H 4H 5S'''), PokerHand('''2S 3H 4H 5S 6C''')]
     pokerhands.sort(reverse=__A)
     assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C"




def lowerCAmelCase    ():



     """simple docstring"""



     _a           =    PokerHand('''2C 4S AS 3D 5C''')
     _a           =    True
     _a           =    [5, 4, 3, 2, 14]
     for _ in range(10):
          assert pokerhand._is_five_high_straight() == expected
          assert pokerhand._card_values == expected_card_values




def lowerCAmelCase    ():



     """simple docstring"""



     _a           =    0
     _a           =    os.path.abspath(os.path.dirname(__A))
     _a           =    os.path.join(__A    ,      '''poker_hands.txt''')
     with open(__A) as file_hand:
          for line in file_hand:
               _a           =    line[:14].strip()
               _a           =    line[15:].strip()
               _a    ,       _a           =    PokerHand(__A), PokerHand(__A)
               _a           =    player.compare_with(__A)
               if output == "Win":
                    answer += 1
     assert answer == 376








'''simple docstring'''





import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)




def lowerCAmelCase    (__A    ,      __A    ,      __A):



     """simple docstring"""



     if isinstance(__A    ,      torch.Tensor):
          return image
     elif isinstance(__A    ,      PIL.Image.Image):
          _a           =    [image]

     if isinstance(image[0]    ,      PIL.Image.Image):
          _a           =    [np.array(i.resize((w, h)    ,      resample=PIL_INTERPOLATION['''lanczos''']))[None, :] for i in image]
          _a           =    np.concatenate(__A    ,      axis=0)
          _a           =    np.array(__A).astype(np.floataa) / 2_55.0
          _a           =    image.transpose(0    ,      3    ,      1    ,      2)
          _a           =    2.0 * image - 1.0
          _a           =    torch.from_numpy(__A)
     elif isinstance(image[0]    ,      torch.Tensor):
          _a           =    torch.cat(__A    ,      dim=0)
     return image




def lowerCAmelCase    (__A    ,      __A    ,      __A    ,      __A=0.99_95):



     """simple docstring"""



     if not isinstance(__A    ,      np.ndarray):
          _a           =    True
          _a           =    va.device
          _a           =    va.cpu().numpy()
          _a           =    va.cpu().numpy()

     _a           =    np.sum(va * va / (np.linalg.norm(__A) * np.linalg.norm(__A)))
     if np.abs(__A) > DOT_THRESHOLD:
          _a           =    (1 - t) * va + t * va
     else:
          _a           =    np.arccos(__A)
          _a           =    np.sin(__A)
          _a           =    theta_a * t
          _a           =    np.sin(__A)
          _a           =    np.sin(theta_a - theta_t) / sin_theta_a
          _a           =    sin_theta_t / sin_theta_a
          _a           =    sa * va + sa * va

     if inputs_are_torch:
          _a           =    torch.from_numpy(__A).to(__A)

     return va




def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     _a           =    F.normalize(__A    ,      dim=-1)
     _a           =    F.normalize(__A    ,      dim=-1)
     return (x - y).norm(dim=-1).div(2).arcsin().pow(2).mul(2)




def lowerCAmelCase    (__A    ,      __A):



     """simple docstring"""



     for param in model.parameters():
          _a           =    value






class __A     (    A		):



 '''simple docstring'''







 def __init__(self					,  A					,  A					,  A					,  A					,  A					,  A					,  A					,  A=None					,  A=None					,  A=None					,  )       ->	str:


      """simple docstring"""



      super().__init__()
      self.register_modules(
          vae=A					,  text_encoder=A					,  clip_model=A					,  tokenizer=A					,  unet=A					,  scheduler=A					,  feature_extractor=A					,  coca_model=A					,  coca_tokenizer=A					,  coca_transform=A					,  )
      _a           =    (
          feature_extractor.size
          if isinstance(feature_extractor.size					,  A			)
          else feature_extractor.size['''shortest_edge''']
      )
      _a           =    transforms.Normalize(mean=feature_extractor.image_mean					,  std=feature_extractor.image_std			)
      set_requires_grad(self.text_encoder					,  A			)
      set_requires_grad(self.clip_model					,  A			)



 def    a__    (self					,  A = "auto"			)       ->	Union[str, Any]:


      """simple docstring"""



      if slice_size == "auto":
           # half the attention head size is usually a good trade-off between
           # speed and memory
           _a           =    self.unet.config.attention_head_dim // 2
      self.unet.set_attention_slice(A			)



 def    a__    (self			)       ->	Optional[Any]:


      """simple docstring"""



      self.enable_attention_slicing(A			)



 def    a__    (self			)       ->	int:


      """simple docstring"""



      set_requires_grad(self.vae					,  A			)



 def    a__    (self			)       ->	Union[str, Any]:


      """simple docstring"""



      set_requires_grad(self.vae					,  A			)



 def    a__    (self			)       ->	Dict:


      """simple docstring"""



      set_requires_grad(self.unet					,  A			)



 def    a__    (self			)       ->	str:


      """simple docstring"""



      set_requires_grad(self.unet					,  A			)



 def    a__    (self					,  A					,  A					,  A			)       ->	Optional[Any]:


      """simple docstring"""



      _a           =    min(int(num_inference_steps * strength			)					,  A			)

      _a           =    max(num_inference_steps - init_timestep					,  0			)
      _a           =    self.scheduler.timesteps[t_start:]

      return timesteps, num_inference_steps - t_start



 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A=None			)       ->	List[str]:


      """simple docstring"""



      if not isinstance(A					,  torch.Tensor			):
           raise ValueError(f'''`image` has to be of type `torch.Tensor` but is {type(A			)}'''			)

      _a           =    image.to(device=A					,  dtype=A			)

      if isinstance(A					,  A			):
           _a           =    [
               self.vae.encode(image[i : i + 1]			).latent_dist.sample(generator[i]			) for i in range(A			)
           ]
           _a           =    torch.cat(A					,  dim=0			)
      else:
           _a           =    self.vae.encode(A			).latent_dist.sample(A			)

      # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _a           =    0.18215 * init_latents
      _a           =    init_latents.repeat_interleave(A					,  dim=0			)

      _a           =    randn_tensor(init_latents.shape					,  generator=A					,  device=A					,  dtype=A			)

      # get latents
      _a           =    self.scheduler.add_noise(A					,  A					,  A			)
      _a           =    init_latents

      return latents



 def    a__    (self					,  A			)       ->	Tuple:


      """simple docstring"""



      _a           =    self.coca_transform(A			).unsqueeze(0			)
      with torch.no_grad(), torch.cuda.amp.autocast():
           _a           =    self.coca_model.generate(transformed_image.to(device=self.device					,  dtype=self.coca_model.dtype			)			)
      _a           =    self.coca_tokenizer.decode(generated[0].cpu().numpy()			)
      return generated.split('''<end_of_text>'''			)[0].replace('''<start_of_text>'''					,  ''''''			).rstrip(''' .,'''			)



 def    a__    (self					,  A					,  A			)       ->	List[Any]:


      """simple docstring"""



      _a           =    self.feature_extractor.preprocess(A			)
      _a           =    torch.from_numpy(clip_image_input['''pixel_values'''][0]			).unsqueeze(0			).to(self.device			).half()
      _a           =    self.clip_model.get_image_features(A			)
      _a           =    image_embeddings_clip / image_embeddings_clip.norm(p=2					,  dim=-1					,  keepdim=A			)
      _a           =    image_embeddings_clip.repeat_interleave(A					,  dim=0			)
      return image_embeddings_clip



 @torch.enable_grad()
 def    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A					,  A					,  )       ->	Union[str, Any]:


      """simple docstring"""



      _a           =    latents.detach().requires_grad_()

      _a           =    self.scheduler.scale_model_input(A					,  A			)

      # predict the noise residual
      _a           =    self.unet(A					,  A					,  encoder_hidden_states=A			).sample

      if isinstance(self.scheduler					,  (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)			):
           _a           =    self.scheduler.alphas_cumprod[timestep]
           _a           =    1 - alpha_prod_t
           # compute predicted original sample from predicted noise also called
           # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
           _a           =    (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

           _a           =    torch.sqrt(A			)
           _a           =    pred_original_sample * (fac) + latents * (1 - fac)
      elif isinstance(self.scheduler					,  A			):
           _a           =    self.scheduler.sigmas[index]
           _a           =    latents - sigma * noise_pred
      else:
           raise ValueError(f'''scheduler type {type(self.scheduler			)} not supported'''			)

      # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _a           =    1 / 0.18215 * sample
      _a           =    self.vae.decode(A			).sample
      _a           =    (image / 2 + 0.5).clamp(0					,  1			)

      _a           =    transforms.Resize(self.feature_extractor_size			)(A			)
      _a           =    self.normalize(A			).to(latents.dtype			)

      _a           =    self.clip_model.get_image_features(A			)
      _a           =    image_embeddings_clip / image_embeddings_clip.norm(p=2					,  dim=-1					,  keepdim=A			)

      _a           =    spherical_dist_loss(A					,  A			).mean() * clip_guidance_scale

      _a           =    -torch.autograd.grad(A					,  A			)[0]

      if isinstance(self.scheduler					,  A			):
           _a           =    latents.detach() + grads * (sigma**2)
           _a           =    noise_pred_original
      else:
           _a           =    noise_pred_original - torch.sqrt(A			) * grads
      return noise_pred, latents



 @torch.no_grad()
 def __call__(self					,  A					,  A					,  A = None					,  A = None					,  A = 512					,  A = 512					,  A = 0.6					,  A = 50					,  A = 7.5					,  A = 1					,  A = 0.0					,  A = 100					,  A = None					,  A = "pil"					,  A = True					,  A = 0.8					,  A = 0.1					,  A = 0.1					,  )       ->	str:


      """simple docstring"""



      if isinstance(A					,  A			) and len(A			) != batch_size:
           raise ValueError(f'''You have passed {batch_size} batch_size, but only {len(A			)} generators.'''			)

      if height % 8 != 0 or width % 8 != 0:
           raise ValueError(f'''`height` and `width` have to be divisible by 8 but are {height} and {width}.'''			)

      if isinstance(A					,  torch.Generator			) and batch_size > 1:
           _a           =    [generator] + [None] * (batch_size - 1)

      _a           =    [
          ('''model''', self.coca_model is None),
          ('''tokenizer''', self.coca_tokenizer is None),
          ('''transform''', self.coca_transform is None),
      ]
      _a           =    [x[0] for x in coca_is_none if x[1]]
      _a           =    ''', '''.join(A			)
      # generate prompts with coca model if prompt is None
      if content_prompt is None:
           if len(A			):
                raise ValueError(
                    f'''Content prompt is None and CoCa [{coca_is_none_str}] is None.'''
                    f'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'''			)
           _a           =    self.get_image_description(A			)
      if style_prompt is None:
           if len(A			):
                raise ValueError(
                    f'''Style prompt is None and CoCa [{coca_is_none_str}] is None.'''
                    f''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'''			)
           _a           =    self.get_image_description(A			)

      # get prompt text embeddings for content and style
      _a           =    self.tokenizer(
          A					,  padding='''max_length'''					,  max_length=self.tokenizer.model_max_length					,  truncation=A					,  return_tensors='''pt'''					,  )
      _a           =    self.text_encoder(content_text_input.input_ids.to(self.device			)			)[0]

      _a           =    self.tokenizer(
          A					,  padding='''max_length'''					,  max_length=self.tokenizer.model_max_length					,  truncation=A					,  return_tensors='''pt'''					,  )
      _a           =    self.text_encoder(style_text_input.input_ids.to(self.device			)			)[0]

      _a           =    slerp(A					,  A					,  A			)

      # duplicate text embeddings for each generation per prompt
      _a           =    text_embeddings.repeat_interleave(A					,  dim=0			)

      # set timesteps
      _a           =    '''offset''' in set(inspect.signature(self.scheduler.set_timesteps			).parameters.keys()			)
      _a           =    {}
      if accepts_offset:
           _a           =    1

      self.scheduler.set_timesteps(A					,  **A			)
      # Some schedulers like PNDM have timesteps as arrays
      # It's more optimized to move all timesteps to correct device beforehand
      self.scheduler.timesteps.to(self.device			)

      _a    ,       _a           =    self.get_timesteps(A					,  A					,  self.device			)
      _a           =    timesteps[:1].repeat(A			)

      # Preprocess image
      _a           =    preprocess(A					,  A					,  A			)
      _a           =    self.prepare_latents(
          A					,  A					,  A					,  text_embeddings.dtype					,  self.device					,  A			)

      _a           =    preprocess(A					,  A					,  A			)
      _a           =    self.prepare_latents(
          A					,  A					,  A					,  text_embeddings.dtype					,  self.device					,  A			)

      _a           =    slerp(A					,  A					,  A			)

      if clip_guidance_scale > 0:
           _a           =    self.get_clip_image_embeddings(A					,  A			)
           _a           =    self.get_clip_image_embeddings(A					,  A			)
           _a           =    slerp(
               A					,  A					,  A			)

      # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
      # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
      # corresponds to doing no classifier free guidance.
      _a           =    guidance_scale > 1.0
      # get unconditional embeddings for classifier free guidance
      if do_classifier_free_guidance:
           _a           =    content_text_input.input_ids.shape[-1]
           _a           =    self.tokenizer(['''''']					,  padding='''max_length'''					,  max_length=A					,  return_tensors='''pt'''			)
           _a           =    self.text_encoder(uncond_input.input_ids.to(self.device			)			)[0]
           # duplicate unconditional embeddings for each generation per prompt
           _a           =    uncond_embeddings.repeat_interleave(A					,  dim=0			)

           # For classifier free guidance, we need to do two forward passes.
           # Here we concatenate the unconditional and text embeddings into a single batch
           # to avoid doing two forward passes
           _a           =    torch.cat([uncond_embeddings, text_embeddings]			)

      # get the initial random noise unless the user supplied it

      # Unlike in other pipelines, latents need to be generated in the target device
      # for 1-to-1 results reproducibility with the CompVis implementation.
      # However this currently doesn't work in `mps`.
      _a           =    (batch_size, self.unet.config.in_channels, height // 8, width // 8)
      _a           =    text_embeddings.dtype
      if latents is None:
           if self.device.type == "mps":
                # randn does not work reproducibly on mps
                _a           =    torch.randn(A					,  generator=A					,  device='''cpu'''					,  dtype=A			).to(
                    self.device			)
           else:
                _a           =    torch.randn(A					,  generator=A					,  device=self.device					,  dtype=A			)
      else:
           if latents.shape != latents_shape:
                raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''			)
           _a           =    latents.to(self.device			)

      # scale the initial noise by the standard deviation required by the scheduler
      _a           =    latents * self.scheduler.init_noise_sigma

      # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
      # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
      # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
      # and should be between [0, 1]
      _a           =    '''eta''' in set(inspect.signature(self.scheduler.step			).parameters.keys()			)
      _a           =    {}
      if accepts_eta:
           _a           =    eta

      # check if the scheduler accepts generator
      _a           =    '''generator''' in set(inspect.signature(self.scheduler.step			).parameters.keys()			)
      if accepts_generator:
           _a           =    generator

      with self.progress_bar(total=A			):
           for i, t in enumerate(A			):
                # expand the latents if we are doing classifier free guidance
                _a           =    torch.cat([latents] * 2			) if do_classifier_free_guidance else latents
                _a           =    self.scheduler.scale_model_input(A					,  A			)

                # predict the noise residual
                _a           =    self.unet(A					,  A					,  encoder_hidden_states=A			).sample

                # perform classifier free guidance
                if do_classifier_free_guidance:
                     _a    ,       _a           =    noise_pred.chunk(2			)
                     _a           =    noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                # perform clip guidance
                if clip_guidance_scale > 0:
                     _a           =    (
                         text_embeddings.chunk(2			)[1] if do_classifier_free_guidance else text_embeddings
                     )
                     _a    ,       _a           =    self.cond_fn(
                         A					,  A					,  A					,  A					,  A					,  A					,  A					,  )

                # compute the previous noisy sample x_t -> x_t-1
                _a           =    self.scheduler.step(A					,  A					,  A					,  **A			).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _a           =    1 / 0.18215 * latents
      _a           =    self.vae.decode(A			).sample

      _a           =    (image / 2 + 0.5).clamp(0					,  1			)
      _a           =    image.cpu().permute(0					,  2					,  3					,  1			).numpy()

      if output_type == "pil":
           _a           =    self.numpy_to_pil(A			)

      if not return_dict:
           return (image, None)

      return StableDiffusionPipelineOutput(images=A					,  nsfw_content_detected=A			)



