






'''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 						UpperCamelCase	(			a		,						a		,						a			)				->     int:






     '''simple docstring'''
     if isinstance(lowerCAmelCase__		,						torch.Tensor			):
          return image
     elif isinstance(lowerCAmelCase__		,						PIL.Image.Image			):
          __magic_name__						       =    [image]

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




def 						UpperCamelCase	(			a		,						a		,						a		,						a=0.99_95			)				->     Any:






     '''simple docstring'''
     if not isinstance(lowerCAmelCase__		,						np.ndarray			):
          __magic_name__						       =    True
          __magic_name__						       =    va.device
          __magic_name__						       =    va.cpu().numpy()
          __magic_name__						       =    va.cpu().numpy()

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

     if inputs_are_torch:
          __magic_name__						       =    torch.from_numpy(lowerCAmelCase__			).to(lowerCAmelCase__			)

     return va




def 						UpperCamelCase	(			a		,						a			)				->     List[str]:






     '''simple docstring'''
     __magic_name__						       =    F.normalize(lowerCAmelCase__		,						dim=-1			)
     __magic_name__						       =    F.normalize(lowerCAmelCase__		,						dim=-1			)
     return (x - y).norm(dim=-1			).div(2			).arcsin().pow(2			).mul(2			)




def 						UpperCamelCase	(			a		,						a			)				->     Optional[Any]:






     '''simple docstring'''
     for param in model.parameters():
          __magic_name__						       =    value






class   _SCREAMING_SNAKE_CASE   (   SCREAMING_SNAKE_CASE__     ):



 def __init__(   self		:   Dict			,				a__		:   Dict			,				a__		:   Any			,				a__		:   str			,				a__		:   Any			,				a__		:   Dict			,				a__		:   Optional[int]			,				a__		:   int			,				a__		:   int=None			,				a__		:   Union[str, Any]=None			,				a__		:   Any=None			,				):
      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__			,				)
      __magic_name__						       =    (
          feature_extractor.size
          if isinstance(feature_extractor.size			,				A__      )
          else feature_extractor.size['''shortest_edge''']
      )
      __magic_name__						       =    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 			snake_case__  (   self		:   Optional[int]			,				a__		:   Optional[int] = "auto"      ):
      if slice_size == "auto":
           # half the attention head size is usually a good trade-off between
           # speed and memory
           __magic_name__						       =    self.unet.config.attention_head_dim // 2
      self.unet.set_attention_slice(A__      )



 def 			snake_case__  (   self		:   Dict      ):
      self.enable_attention_slicing(A__      )



 def 			snake_case__  (   self		:   Dict      ):
      set_requires_grad(self.vae			,				A__      )



 def 			snake_case__  (   self		:   Optional[int]      ):
      set_requires_grad(self.vae			,				A__      )



 def 			snake_case__  (   self		:   str      ):
      set_requires_grad(self.unet			,				A__      )



 def 			snake_case__  (   self		:   Optional[int]      ):
      set_requires_grad(self.unet			,				A__      )



 def 			snake_case__  (   self		:   Dict			,				a__		:   List[Any]			,				a__		:   List[Any]			,				a__		:   Optional[int]      ):
      # get the original timestep using init_timestep
      __magic_name__						       =    min(int(num_inference_steps * strength      )			,				A__      )

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

      return timesteps, num_inference_steps - t_start



 def 			snake_case__  (   self		:   List[Any]			,				a__		:   Union[str, Any]			,				a__		:   str			,				a__		:   Any			,				a__		:   Optional[Any]			,				a__		:   Optional[Any]			,				a__		:   str=None      ):
      if not isinstance(A__			,				torch.Tensor      ):
           raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(A__      )}'''      )

      __magic_name__						       =    image.to(device=A__			,				dtype=A__      )

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

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

      __magic_name__						       =    randn_tensor(init_latents.shape			,				generator=A__			,				device=A__			,				dtype=A__      )

      # get latents
      __magic_name__						       =    self.scheduler.add_noise(A__			,				A__			,				A__      )
      __magic_name__						       =    init_latents

      return latents



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



 def 			snake_case__  (   self		:   List[Any]			,				a__		:   List[Any]			,				a__		:   Optional[Any]      ):
      __magic_name__						       =    self.feature_extractor.preprocess(A__      )
      __magic_name__						       =    torch.from_numpy(clip_image_input['''pixel_values'''][0]      ).unsqueeze(0      ).to(self.device      ).half()
      __magic_name__						       =    self.clip_model.get_image_features(A__      )
      __magic_name__						       =    image_embeddings_clip / image_embeddings_clip.norm(p=2			,				dim=-1			,				keepdim=A__      )
      __magic_name__						       =    image_embeddings_clip.repeat_interleave(A__			,				dim=0      )
      return image_embeddings_clip



 @torch.enable_grad()
 def 			snake_case__  (   self		:   Union[str, Any]			,				a__		:   Tuple			,				a__		:   List[Any]			,				a__		:   int			,				a__		:   str			,				a__		:   List[str]			,				a__		:   Any			,				a__		:   Union[str, Any]			,				):
      __magic_name__						       =    latents.detach().requires_grad_()

      __magic_name__						       =    self.scheduler.scale_model_input(A__			,				A__      )

      # predict the noise residual
      __magic_name__						       =    self.unet(A__			,				A__			,				encoder_hidden_states=A__      ).sample

      if isinstance(self.scheduler			,				(PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)      ):
           __magic_name__						       =    self.scheduler.alphas_cumprod[timestep]
           __magic_name__						       =    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
           __magic_name__						       =    (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

           __magic_name__						       =    torch.sqrt(A__      )
           __magic_name__						       =    pred_original_sample * (fac) + latents * (1 - fac)
      elif isinstance(self.scheduler			,				A__      ):
           __magic_name__						       =    self.scheduler.sigmas[index]
           __magic_name__						       =    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
      __magic_name__						       =    1 / 0.18_215 * sample
      __magic_name__						       =    self.vae.decode(A__      ).sample
      __magic_name__						       =    (image / 2 + 0.5).clamp(0			,				1      )

      __magic_name__						       =    transforms.Resize(self.feature_extractor_size      )(A__      )
      __magic_name__						       =    self.normalize(A__      ).to(latents.dtype      )

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

      __magic_name__						       =    spherical_dist_loss(A__			,				A__      ).mean() * clip_guidance_scale

      __magic_name__						       =    -torch.autograd.grad(A__			,				A__      )[0]

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



 @torch.no_grad()
 def __call__(   self		:   List[Any]			,				a__		:   Optional[Any]			,				a__		:   Optional[int]			,				a__		:   Tuple = None			,				a__		:   Tuple = None			,				a__		:   int = 512			,				a__		:   Optional[int] = 512			,				a__		:   Optional[Any] = 0.6			,				a__		:   Optional[Any] = 50			,				a__		:   Union[str, Any] = 7.5			,				a__		:   Optional[Any] = 1			,				a__		:   int = 0.0			,				a__		:   List[str] = 100			,				a__		:   List[Any] = None			,				a__		:   Dict = "pil"			,				a__		:   Dict = True			,				a__		:   Union[str, Any] = 0.8			,				a__		:   Optional[Any] = 0.1			,				a__		:   List[str] = 0.1			,				):
      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:
           __magic_name__						       =    [generator] + [None] * (batch_size - 1)

      __magic_name__						       =    [
          ('''model''', self.coca_model is None),
          ('''tokenizer''', self.coca_tokenizer is None),
          ('''transform''', self.coca_transform is None),
      ]
      __magic_name__						       =    [x[0] for x in coca_is_none if x[1]]
      __magic_name__						       =    ''', '''.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.'''      )
           __magic_name__						       =    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.'''      )
           __magic_name__						       =    self.get_image_description(A__      )

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

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

      __magic_name__						       =    slerp(A__			,				A__			,				A__      )

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

      # set timesteps
      __magic_name__						       =    '''offset''' in set(inspect.signature(self.scheduler.set_timesteps      ).parameters.keys()      )
      __magic_name__						       =    {}
      if accepts_offset:
           __magic_name__						       =    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      )

      __magic_name__       ,  __magic_name__						       =    self.get_timesteps(A__			,				A__			,				self.device      )
      __magic_name__						       =    timesteps[:1].repeat(A__      )

      # Preprocess image
      __magic_name__						       =    preprocess(A__			,				A__			,				A__      )
      __magic_name__						       =    self.prepare_latents(
          A__			,				A__			,				A__			,				text_embeddings.dtype			,				self.device			,				A__      )

      __magic_name__						       =    preprocess(A__			,				A__			,				A__      )
      __magic_name__						       =    self.prepare_latents(
          A__			,				A__			,				A__			,				text_embeddings.dtype			,				self.device			,				A__      )

      __magic_name__						       =    slerp(A__			,				A__			,				A__      )

      if clip_guidance_scale > 0:
           __magic_name__						       =    self.get_clip_image_embeddings(A__			,				A__      )
           __magic_name__						       =    self.get_clip_image_embeddings(A__			,				A__      )
           __magic_name__						       =    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.
      __magic_name__						       =    guidance_scale > 1.0
      # get unconditional embeddings for classifier free guidance
      if do_classifier_free_guidance:
           __magic_name__						       =    content_text_input.input_ids.shape[-1]
           __magic_name__						       =    self.tokenizer(['''''']			,				padding='''max_length'''			,				max_length=A__			,				return_tensors='''pt'''      )
           __magic_name__						       =    self.text_encoder(uncond_input.input_ids.to(self.device      )      )[0]
           # duplicate unconditional embeddings for each generation per prompt
           __magic_name__						       =    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
           __magic_name__						       =    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`.
      __magic_name__						       =    (batch_size, self.unet.config.in_channels, height // 8, width // 8)
      __magic_name__						       =    text_embeddings.dtype
      if latents is None:
           if self.device.type == "mps":
                # randn does not work reproducibly on mps
                __magic_name__						       =    torch.randn(A__			,				generator=A__			,				device='''cpu'''			,				dtype=A__      ).to(
                    self.device      )
           else:
                __magic_name__						       =    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}'''      )
           __magic_name__						       =    latents.to(self.device      )

      # scale the initial noise by the standard deviation required by the scheduler
      __magic_name__						       =    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]
      __magic_name__						       =    '''eta''' in set(inspect.signature(self.scheduler.step      ).parameters.keys()      )
      __magic_name__						       =    {}
      if accepts_eta:
           __magic_name__						       =    eta

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

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

                # predict the noise residual
                __magic_name__						       =    self.unet(A__			,				A__			,				encoder_hidden_states=A__      ).sample

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

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

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

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

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

      if output_type == "pil":
           __magic_name__						       =    self.numpy_to_pil(A__      )

      if not return_dict:
           return (image, None)

      return StableDiffusionPipelineOutput(images=A__			,				nsfw_content_detected=A__      )









'''simple docstring'''




import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TextaTextGenerationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.utils import is_torch_available

from .test_pipelines_common import ANY


if is_torch_available():
      import torch






@is_pipeline_test
class   _SCREAMING_SNAKE_CASE   (   unittest.TestCase     ):
 __SCREAMING_SNAKE_CASE					:List[Any]      	=					MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
 __SCREAMING_SNAKE_CASE					:Any      	=					TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING



 def 			snake_case__  (   self		:   Tuple			,				a__		:   Tuple			,				a__		:   int			,				a__		:   int      ):
      __magic_name__						       =    TextaTextGenerationPipeline(model=a__			,				tokenizer=a__      )
      return generator, ["Something to write", "Something else"]



 def 			snake_case__  (   self		:   List[str]			,				a__		:   List[Any]			,				a__		:   List[str]      ):
      __magic_name__						       =    generator('''Something there'''      )
      self.assertEqual(a__			,				[{'''generated_text''': ANY(a__      )}]      )
      # These are encoder decoder, they don't just append to incoming string
      self.assertFalse(outputs[0]['''generated_text'''].startswith('''Something there'''      )      )

      __magic_name__						       =    generator(['''This is great !''', '''Something else''']			,				num_return_sequences=2			,				do_sample=a__      )
      self.assertEqual(
          a__			,				[
              [{'''generated_text''': ANY(a__      )}, {'''generated_text''': ANY(a__      )}],
              [{'''generated_text''': ANY(a__      )}, {'''generated_text''': ANY(a__      )}],
          ]			,				)

      __magic_name__						       =    generator(
          ['''This is great !''', '''Something else''']			,				num_return_sequences=2			,				batch_size=2			,				do_sample=a__      )
      self.assertEqual(
          a__			,				[
              [{'''generated_text''': ANY(a__      )}, {'''generated_text''': ANY(a__      )}],
              [{'''generated_text''': ANY(a__      )}, {'''generated_text''': ANY(a__      )}],
          ]			,				)

      with self.assertRaises(a__      ):
           generator(4      )



 @require_torch
 def 			snake_case__  (   self		:   Any      ):
      __magic_name__						       =    pipeline('''text2text-generation'''			,				model='''patrickvonplaten/t5-tiny-random'''			,				framework='''pt'''      )
      # do_sample=False necessary for reproducibility
      __magic_name__						       =    generator('''Something there'''			,				do_sample=a__      )
      self.assertEqual(a__			,				[{'''generated_text''': ''''''}]      )

      __magic_name__						       =    3
      __magic_name__						       =    generator(
          '''Something there'''			,				num_return_sequences=a__			,				num_beams=a__			,				)
      __magic_name__						       =    [
          {'''generated_text''': '''Beide Beide Beide Beide Beide Beide Beide Beide Beide'''},
          {'''generated_text''': '''Beide Beide Beide Beide Beide Beide Beide Beide'''},
          {'''generated_text''': ''''''},
      ]
      self.assertEqual(a__			,				a__      )

      __magic_name__						       =    generator('''This is a test'''			,				do_sample=a__			,				num_return_sequences=2			,				return_tensors=a__      )
      self.assertEqual(
          a__			,				[
              {'''generated_token_ids''': ANY(torch.Tensor      )},
              {'''generated_token_ids''': ANY(torch.Tensor      )},
          ]			,				)
      __magic_name__						       =    generator.model.config.eos_token_id
      __magic_name__						       =    '''<pad>'''
      __magic_name__						       =    generator(
          ['''This is a test''', '''This is a second test''']			,				do_sample=a__			,				num_return_sequences=2			,				batch_size=2			,				return_tensors=a__			,				)
      self.assertEqual(
          a__			,				[
              [
                  {'''generated_token_ids''': ANY(torch.Tensor      )},
                  {'''generated_token_ids''': ANY(torch.Tensor      )},
              ],
              [
                  {'''generated_token_ids''': ANY(torch.Tensor      )},
                  {'''generated_token_ids''': ANY(torch.Tensor      )},
              ],
          ]			,				)



 @require_tf
 def 			snake_case__  (   self		:   int      ):
      __magic_name__						       =    pipeline('''text2text-generation'''			,				model='''patrickvonplaten/t5-tiny-random'''			,				framework='''tf'''      )
      # do_sample=False necessary for reproducibility
      __magic_name__						       =    generator('''Something there'''			,				do_sample=a__      )
      self.assertEqual(a__			,				[{'''generated_text''': ''''''}]      )






