





from collections import deque
from math import floor
from random import random
from time import time




class     _a  :

      """simple docstring"""


      def __init__(						self:       str ):
          '''simple docstring'''


          UpperCamelCase__:     Tuple     							=			{}






      def        UpperCAmelCase_    (						self:       List[str]     ,  __lowerCamelCase:       Tuple     ,  __lowerCamelCase:       str     ,  __lowerCamelCase:       List[Any]=1 ):
          '''simple docstring'''


          if self.graph.get(A__ ):
              if self.graph[u].count([w, v] ) == 0:
                  self.graph[u].append([w, v] )
          else:
              UpperCamelCase__:     Dict     							=			[[w, v]]
          if not self.graph.get(A__ ):
              UpperCamelCase__:     List[str]     							=			[]






      def        UpperCAmelCase_    (						self:       List[Any] ):
          '''simple docstring'''


          return list(self.graph )






      def        UpperCAmelCase_    (						self:       int     ,  __lowerCamelCase:       List[Any]     ,  __lowerCamelCase:       Dict ):
          '''simple docstring'''


          if self.graph.get(A__ ):
              for _ in self.graph[u]:
                  if _[1] == v:
                      self.graph[u].remove(A__ )






      def        UpperCAmelCase_    (						self:       List[str]     ,  __lowerCamelCase:       List[str]=-2     ,  __lowerCamelCase:       Dict=-1 ):
          '''simple docstring'''


          if s == d:
              return []
          UpperCamelCase__:     List[Any]     							=			[]
          UpperCamelCase__:     Any     							=			[]
          if s == -2:
              UpperCamelCase__:     List[Any]     							=			list(self.graph )[0]
          stack.append(A__ )
          visited.append(A__ )
          UpperCamelCase__:     Optional[Any]     							=			s

          while True:
              # check if there is any non isolated nodes
              if len(self.graph[s] ) != 0:
                  UpperCamelCase__:     Optional[int]     							=			s
                  for node in self.graph[s]:
                      if visited.count(node[1] ) < 1:
                          if node[1] == d:
                              visited.append(A__ )
                              return visited
                          else:
                              stack.append(node[1] )
                              visited.append(node[1] )
                              UpperCamelCase__:     Optional[int]     							=			node[1]
                              break

            # check if all the children are visited
              if s == ss:
                  stack.pop()
                  if len(A__ ) != 0:
                      UpperCamelCase__:     Dict     							=			stack[len(A__ ) - 1]
              else:
                  UpperCamelCase__:     Tuple     							=			ss

              # check if se have reached the starting point
              if len(A__ ) == 0:
                  return visited






      def        UpperCAmelCase_    (						self:       Tuple     ,  __lowerCamelCase:       Optional[Any]=-1 ):
          '''simple docstring'''


          if c == -1:
              UpperCamelCase__:     Optional[int]     							=			floor(random() * 1_0000 ) + 10
          for i in range(A__ ):
              # every vertex has max 100 edges
              for _ in range(floor(random() * 102 ) + 1 ):
                  UpperCamelCase__:     str     							=			floor(random() * c ) + 1
                  if n != i:
                      self.add_pair(A__     ,  A__     ,  1 )






      def        UpperCAmelCase_    (						self:       str     ,  __lowerCamelCase:       Optional[int]=-2 ):
          '''simple docstring'''


          UpperCamelCase__:     Dict     							=			deque()
          UpperCamelCase__:     Optional[Any]     							=			[]
          if s == -2:
              UpperCamelCase__:     str     							=			list(self.graph )[0]
          d.append(A__ )
          visited.append(A__ )
          while d:
              UpperCamelCase__:     Optional[int]     							=			d.popleft()
              if len(self.graph[s] ) != 0:
                  for node in self.graph[s]:
                      if visited.count(node[1] ) < 1:
                          d.append(node[1] )
                          visited.append(node[1] )
          return visited






      def        UpperCAmelCase_    (						self:       List[str]     ,  __lowerCamelCase:       Tuple ):
          '''simple docstring'''


          UpperCamelCase__:     Optional[Any]     							=			0
          for x in self.graph:
              for y in self.graph[x]:
                  if y[1] == u:
                      count += 1
          return count






      def        UpperCAmelCase_    (						self:       Optional[int]     ,  __lowerCamelCase:       str ):
          '''simple docstring'''


          return len(self.graph[u] )






      def        UpperCAmelCase_    (						self:       Optional[int]     ,  __lowerCamelCase:       Dict=-2 ):
          '''simple docstring'''


          UpperCamelCase__:     Optional[Any]     							=			[]
          UpperCamelCase__:     int     							=			[]
          if s == -2:
              UpperCamelCase__:     Any     							=			list(self.graph )[0]
          stack.append(A__ )
          visited.append(A__ )
          UpperCamelCase__:     Dict     							=			s
          UpperCamelCase__:     int     							=			[]

          while True:
              # check if there is any non isolated nodes
              if len(self.graph[s] ) != 0:
                  UpperCamelCase__:     List[Any]     							=			s
                  for node in self.graph[s]:
                      if visited.count(node[1] ) < 1:
                          stack.append(node[1] )
                          visited.append(node[1] )
                          UpperCamelCase__:     str     							=			node[1]
                          break

            # check if all the children are visited
              if s == ss:
                  sorted_nodes.append(stack.pop() )
                  if len(A__ ) != 0:
                      UpperCamelCase__:     Optional[int]     							=			stack[len(A__ ) - 1]
              else:
                  UpperCamelCase__:     Tuple     							=			ss

              # check if se have reached the starting point
              if len(A__ ) == 0:
                  return sorted_nodes






      def        UpperCAmelCase_    (						self:       Dict ):
          '''simple docstring'''


          UpperCamelCase__:     List[str]     							=			[]
          UpperCamelCase__:     int     							=			[]
          UpperCamelCase__:     int     							=			list(self.graph )[0]
          stack.append(A__ )
          visited.append(A__ )
          UpperCamelCase__:     Optional[int]     							=			-2
          UpperCamelCase__:     Optional[Any]     							=			[]
          UpperCamelCase__:     str     							=			s
          UpperCamelCase__:     List[Any]     							=			False
          UpperCamelCase__:     Optional[Any]     							=			set()

          while True:
              # check if there is any non isolated nodes
              if len(self.graph[s] ) != 0:
                  UpperCamelCase__:     Optional[int]     							=			s
                  for node in self.graph[s]:
                      if (
                          visited.count(node[1] ) > 0
                          and node[1] != parent
                          and indirect_parents.count(node[1] ) > 0
                          and not on_the_way_back
                      ):
                          UpperCamelCase__:     Optional[int]     							=			len(A__ ) - 1
                          while len_stack >= 0:
                              if stack[len_stack] == node[1]:
                                  anticipating_nodes.add(node[1] )
                                  break
                              else:
                                  anticipating_nodes.add(stack[len_stack] )
                                  len_stack -= 1
                      if visited.count(node[1] ) < 1:
                          stack.append(node[1] )
                          visited.append(node[1] )
                          UpperCamelCase__:     List[Any]     							=			node[1]
                          break

            # check if all the children are visited
              if s == ss:
                  stack.pop()
                  UpperCamelCase__:     Tuple     							=			True
                  if len(A__ ) != 0:
                      UpperCamelCase__:     List[Any]     							=			stack[len(A__ ) - 1]
              else:
                  UpperCamelCase__:     Optional[Any]     							=			False
                  indirect_parents.append(A__ )
                  UpperCamelCase__:     Optional[Any]     							=			s
                  UpperCamelCase__:     Union[str, Any]     							=			ss

              # check if se have reached the starting point
              if len(A__ ) == 0:
                  return list(A__ )






      def        UpperCAmelCase_    (						self:       Any ):
          '''simple docstring'''


          UpperCamelCase__:     List[Any]     							=			[]
          UpperCamelCase__:     int     							=			[]
          UpperCamelCase__:     List[Any]     							=			list(self.graph )[0]
          stack.append(A__ )
          visited.append(A__ )
          UpperCamelCase__:     int     							=			-2
          UpperCamelCase__:     Union[str, Any]     							=			[]
          UpperCamelCase__:     Union[str, Any]     							=			s
          UpperCamelCase__:     Any     							=			False
          UpperCamelCase__:     Any     							=			set()

          while True:
              # check if there is any non isolated nodes
              if len(self.graph[s] ) != 0:
                  UpperCamelCase__:     Any     							=			s
                  for node in self.graph[s]:
                      if (
                          visited.count(node[1] ) > 0
                          and node[1] != parent
                          and indirect_parents.count(node[1] ) > 0
                          and not on_the_way_back
                      ):
                          UpperCamelCase__:     Tuple     							=			len(A__ ) - 1
                          while len_stack_minus_one >= 0:
                              if stack[len_stack_minus_one] == node[1]:
                                  anticipating_nodes.add(node[1] )
                                  break
                              else:
                                  return True
                      if visited.count(node[1] ) < 1:
                          stack.append(node[1] )
                          visited.append(node[1] )
                          UpperCamelCase__:     List[str]     							=			node[1]
                          break

            # check if all the children are visited
              if s == ss:
                  stack.pop()
                  UpperCamelCase__:     Tuple     							=			True
                  if len(A__ ) != 0:
                      UpperCamelCase__:     Optional[Any]     							=			stack[len(A__ ) - 1]
              else:
                  UpperCamelCase__:     Union[str, Any]     							=			False
                  indirect_parents.append(A__ )
                  UpperCamelCase__:     Tuple     							=			s
                  UpperCamelCase__:     Union[str, Any]     							=			ss

              # check if se have reached the starting point
              if len(A__ ) == 0:
                  return False






      def        UpperCAmelCase_    (						self:       Optional[int]     ,  __lowerCamelCase:       int=-2     ,  __lowerCamelCase:       Tuple=-1 ):
          '''simple docstring'''


          UpperCamelCase__:     Optional[int]     							=			time()
          self.dfs(A__     ,  A__ )
          UpperCamelCase__:     List[str]     							=			time()
          return end - begin






      def        UpperCAmelCase_    (						self:       str     ,  __lowerCamelCase:       Tuple=-2 ):
          '''simple docstring'''


          UpperCamelCase__:     List[str]     							=			time()
          self.bfs(A__ )
          UpperCamelCase__:     List[Any]     							=			time()
          return end - begin




class     _a  :

      """simple docstring"""


      def __init__(						self:       int ):
          '''simple docstring'''


          UpperCamelCase__:     Union[str, Any]     							=			{}






      def        UpperCAmelCase_    (						self:       List[str]     ,  __lowerCamelCase:       str     ,  __lowerCamelCase:       Tuple     ,  __lowerCamelCase:       Dict=1 ):
          '''simple docstring'''


          if self.graph.get(A__ ):
              # if there already is a edge
              if self.graph[u].count([w, v] ) == 0:
                  self.graph[u].append([w, v] )
          else:
              # if u does not exist
              UpperCamelCase__:     Dict     							=			[[w, v]]
          # add the other way
          if self.graph.get(A__ ):
              # if there already is a edge
              if self.graph[v].count([w, u] ) == 0:
                  self.graph[v].append([w, u] )
          else:
              # if u does not exist
              UpperCamelCase__:     int     							=			[[w, u]]






      def        UpperCAmelCase_    (						self:       List[Any]     ,  __lowerCamelCase:       int     ,  __lowerCamelCase:       int ):
          '''simple docstring'''


          if self.graph.get(A__ ):
              for _ in self.graph[u]:
                  if _[1] == v:
                      self.graph[u].remove(A__ )
        # the other way round
          if self.graph.get(A__ ):
              for _ in self.graph[v]:
                  if _[1] == u:
                      self.graph[v].remove(A__ )






      def        UpperCAmelCase_    (						self:       List[Any]     ,  __lowerCamelCase:       Tuple=-2     ,  __lowerCamelCase:       Any=-1 ):
          '''simple docstring'''


          if s == d:
              return []
          UpperCamelCase__:     int     							=			[]
          UpperCamelCase__:     Dict     							=			[]
          if s == -2:
              UpperCamelCase__:     Any     							=			list(self.graph )[0]
          stack.append(A__ )
          visited.append(A__ )
          UpperCamelCase__:     Optional[int]     							=			s

          while True:
              # check if there is any non isolated nodes
              if len(self.graph[s] ) != 0:
                  UpperCamelCase__:     str     							=			s
                  for node in self.graph[s]:
                      if visited.count(node[1] ) < 1:
                          if node[1] == d:
                              visited.append(A__ )
                              return visited
                          else:
                              stack.append(node[1] )
                              visited.append(node[1] )
                              UpperCamelCase__:     Dict     							=			node[1]
                              break

            # check if all the children are visited
              if s == ss:
                  stack.pop()
                  if len(A__ ) != 0:
                      UpperCamelCase__:     Union[str, Any]     							=			stack[len(A__ ) - 1]
              else:
                  UpperCamelCase__:     Any     							=			ss

              # check if se have reached the starting point
              if len(A__ ) == 0:
                  return visited






      def        UpperCAmelCase_    (						self:       str     ,  __lowerCamelCase:       List[str]=-1 ):
          '''simple docstring'''


          if c == -1:
              UpperCamelCase__:     int     							=			floor(random() * 1_0000 ) + 10
          for i in range(A__ ):
              # every vertex has max 100 edges
              for _ in range(floor(random() * 102 ) + 1 ):
                  UpperCamelCase__:     Dict     							=			floor(random() * c ) + 1
                  if n != i:
                      self.add_pair(A__     ,  A__     ,  1 )






      def        UpperCAmelCase_    (						self:       Any     ,  __lowerCamelCase:       List[Any]=-2 ):
          '''simple docstring'''


          UpperCamelCase__:     Optional[Any]     							=			deque()
          UpperCamelCase__:     Union[str, Any]     							=			[]
          if s == -2:
              UpperCamelCase__:     str     							=			list(self.graph )[0]
          d.append(A__ )
          visited.append(A__ )
          while d:
              UpperCamelCase__:     List[str]     							=			d.popleft()
              if len(self.graph[s] ) != 0:
                  for node in self.graph[s]:
                      if visited.count(node[1] ) < 1:
                          d.append(node[1] )
                          visited.append(node[1] )
          return visited






      def        UpperCAmelCase_    (						self:       List[Any]     ,  __lowerCamelCase:       Optional[Any] ):
          '''simple docstring'''


          return len(self.graph[u] )






      def        UpperCAmelCase_    (						self:       List[str] ):
          '''simple docstring'''


          UpperCamelCase__:     Tuple     							=			[]
          UpperCamelCase__:     str     							=			[]
          UpperCamelCase__:     Tuple     							=			list(self.graph )[0]
          stack.append(A__ )
          visited.append(A__ )
          UpperCamelCase__:     Any     							=			-2
          UpperCamelCase__:     Any     							=			[]
          UpperCamelCase__:     Optional[int]     							=			s
          UpperCamelCase__:     List[str]     							=			False
          UpperCamelCase__:     Dict     							=			set()

          while True:
              # check if there is any non isolated nodes
              if len(self.graph[s] ) != 0:
                  UpperCamelCase__:     str     							=			s
                  for node in self.graph[s]:
                      if (
                          visited.count(node[1] ) > 0
                          and node[1] != parent
                          and indirect_parents.count(node[1] ) > 0
                          and not on_the_way_back
                      ):
                          UpperCamelCase__:     Any     							=			len(A__ ) - 1
                          while len_stack >= 0:
                              if stack[len_stack] == node[1]:
                                  anticipating_nodes.add(node[1] )
                                  break
                              else:
                                  anticipating_nodes.add(stack[len_stack] )
                                  len_stack -= 1
                      if visited.count(node[1] ) < 1:
                          stack.append(node[1] )
                          visited.append(node[1] )
                          UpperCamelCase__:     Optional[Any]     							=			node[1]
                          break

            # check if all the children are visited
              if s == ss:
                  stack.pop()
                  UpperCamelCase__:     Tuple     							=			True
                  if len(A__ ) != 0:
                      UpperCamelCase__:     List[str]     							=			stack[len(A__ ) - 1]
              else:
                  UpperCamelCase__:     Tuple     							=			False
                  indirect_parents.append(A__ )
                  UpperCamelCase__:     Dict     							=			s
                  UpperCamelCase__:     Union[str, Any]     							=			ss

              # check if se have reached the starting point
              if len(A__ ) == 0:
                  return list(A__ )






      def        UpperCAmelCase_    (						self:       Any ):
          '''simple docstring'''


          UpperCamelCase__:     Tuple     							=			[]
          UpperCamelCase__:     int     							=			[]
          UpperCamelCase__:     Tuple     							=			list(self.graph )[0]
          stack.append(A__ )
          visited.append(A__ )
          UpperCamelCase__:     Optional[int]     							=			-2
          UpperCamelCase__:     List[Any]     							=			[]
          UpperCamelCase__:     Tuple     							=			s
          UpperCamelCase__:     Union[str, Any]     							=			False
          UpperCamelCase__:     str     							=			set()

          while True:
              # check if there is any non isolated nodes
              if len(self.graph[s] ) != 0:
                  UpperCamelCase__:     Dict     							=			s
                  for node in self.graph[s]:
                      if (
                          visited.count(node[1] ) > 0
                          and node[1] != parent
                          and indirect_parents.count(node[1] ) > 0
                          and not on_the_way_back
                      ):
                          UpperCamelCase__:     Any     							=			len(A__ ) - 1
                          while len_stack_minus_one >= 0:
                              if stack[len_stack_minus_one] == node[1]:
                                  anticipating_nodes.add(node[1] )
                                  break
                              else:
                                  return True
                      if visited.count(node[1] ) < 1:
                          stack.append(node[1] )
                          visited.append(node[1] )
                          UpperCamelCase__:     str     							=			node[1]
                          break

            # check if all the children are visited
              if s == ss:
                  stack.pop()
                  UpperCamelCase__:     List[Any]     							=			True
                  if len(A__ ) != 0:
                      UpperCamelCase__:     Tuple     							=			stack[len(A__ ) - 1]
              else:
                  UpperCamelCase__:     Dict     							=			False
                  indirect_parents.append(A__ )
                  UpperCamelCase__:     Dict     							=			s
                  UpperCamelCase__:     Optional[Any]     							=			ss

              # check if se have reached the starting point
              if len(A__ ) == 0:
                  return False






      def        UpperCAmelCase_    (						self:       Optional[int] ):
          '''simple docstring'''


          return list(self.graph )






      def        UpperCAmelCase_    (						self:       Dict     ,  __lowerCamelCase:       Tuple=-2     ,  __lowerCamelCase:       List[str]=-1 ):
          '''simple docstring'''


          UpperCamelCase__:     Optional[int]     							=			time()
          self.dfs(A__     ,  A__ )
          UpperCamelCase__:     Dict     							=			time()
          return end - begin






      def        UpperCAmelCase_    (						self:       Optional[int]     ,  __lowerCamelCase:       List[Any]=-2 ):
          '''simple docstring'''


          UpperCamelCase__:     Union[str, Any]     							=			time()
          self.bfs(A__ )
          UpperCamelCase__:     Optional[Any]     							=			time()
          return end - begin



import gc
import unittest

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

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference







class 				lowercase		(					SCREAMING_SNAKE_CASE__       ,  unittest.TestCase		):
							lowercase_       :       Tuple       					=ShapEPipeline
							lowercase_       :       List[Any]       					=['''prompt''']
							lowercase_       :       int       					=['''prompt''']
							lowercase_       :       Union[str, Any]       					=[
							    '''num_images_per_prompt''',
							    '''num_inference_steps''',
							    '''generator''',
							    '''latents''',
							    '''guidance_scale''',
							    '''frame_size''',
							    '''output_type''',
							    '''return_dict''',
							]
							lowercase_       :       Optional[int]       					=False




							@property
							def  A__      (				self):
												return 3_2




							@property
							def  A__      (				self):
												return 3_2




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




							@property
							def  A__      (				self):
												return 8




							@property
							def  A__      (				self):
												lowercase							=						CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')
												return tokenizer




							@property
							def  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						CLIPTextConfig(
												    bos_token_id=0   ,eos_token_id=2   ,hidden_size=self.text_embedder_hidden_size   ,projection_dim=self.text_embedder_hidden_size   ,intermediate_size=3_7   ,layer_norm_eps=1E-05   ,num_attention_heads=4   ,num_hidden_layers=5   ,pad_token_id=1   ,vocab_size=1_0_0_0   ,)
												return CLIPTextModelWithProjection(A__)




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

												lowercase							=						{
												    '''num_attention_heads''': 2,
												    '''attention_head_dim''': 1_6,
												    '''embedding_dim''': self.time_input_dim,
												    '''num_embeddings''': 3_2,
												    '''embedding_proj_dim''': self.text_embedder_hidden_size,
												    '''time_embed_dim''': self.time_embed_dim,
												    '''num_layers''': 1,
												    '''clip_embed_dim''': self.time_input_dim * 2,
												    '''additional_embeddings''': 0,
												    '''time_embed_act_fn''': '''gelu''',
												    '''norm_in_type''': '''layer''',
												    '''encoder_hid_proj_type''': None,
												    '''added_emb_type''': None,
												}

												lowercase							=						PriorTransformer(**A__)
												return model




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

												lowercase							=						{
												    '''param_shapes''': (
												        (self.renderer_dim, 9_3),
												        (self.renderer_dim, 8),
												        (self.renderer_dim, 8),
												        (self.renderer_dim, 8),
												    ),
												    '''d_latent''': self.time_input_dim,
												    '''d_hidden''': self.renderer_dim,
												    '''n_output''': 1_2,
												    '''background''': (
												        0.1,
												        0.1,
												        0.1,
												    ),
												}
												lowercase							=						ShapERenderer(**A__)
												return model




							def  A__      (				self):
												lowercase							=						self.dummy_prior
												lowercase							=						self.dummy_text_encoder
												lowercase							=						self.dummy_tokenizer
												lowercase							=						self.dummy_renderer

												lowercase							=						HeunDiscreteScheduler(
												    beta_schedule='''exp'''   ,num_train_timesteps=1_0_2_4   ,prediction_type='''sample'''   ,use_karras_sigmas=A__   ,clip_sample=A__   ,clip_sample_range=1.0   ,)
												lowercase							=						{
												    '''prior''': prior,
												    '''text_encoder''': text_encoder,
												    '''tokenizer''': tokenizer,
												    '''renderer''': renderer,
												    '''scheduler''': scheduler,
												}

												return components




							def  A__      (				self   ,A__   ,A__=0):
												if str(A__).startswith('''mps'''):
																	lowercase							=						torch.manual_seed(A__)
												else:
																	lowercase							=						torch.Generator(device=A__).manual_seed(A__)
												lowercase							=						{
												    '''prompt''': '''horse''',
												    '''generator''': generator,
												    '''num_inference_steps''': 1,
												    '''frame_size''': 3_2,
												    '''output_type''': '''np''',
												}
												return inputs




							def  A__      (				self):
												lowercase							=						'''cpu'''

												lowercase							=						self.get_dummy_components()

												lowercase							=						self.pipeline_class(**A__)
												lowercase							=						pipe.to(A__)

												pipe.set_progress_bar_config(disable=A__)

												lowercase							=						pipe(**self.get_dummy_inputs(A__))
												lowercase							=						output.images[0]
												lowercase							=						image[0, -3:, -3:, -1]

												assert image.shape == (2_0, 3_2, 3_2, 3)

												lowercase							=						np.array(
												    [
												        0.00039216,
												        0.00039216,
												        0.00039216,
												        0.00039216,
												        0.00039216,
												        0.00039216,
												        0.00039216,
												        0.00039216,
												        0.00039216,
												    ])

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




							def  A__      (				self):
												# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
												self._test_inference_batch_consistent(batch_sizes=[1, 2])




							def  A__      (				self):
												lowercase							=						torch_device == '''cpu'''
												lowercase							=						True

												self._test_inference_batch_single_identical(
												    batch_size=2   ,test_max_difference=A__   ,relax_max_difference=A__   ,)





							def  A__      (				self):
												lowercase							=						self.get_dummy_components()
												lowercase							=						self.pipeline_class(**A__)
												lowercase							=						pipe.to(A__)
												pipe.set_progress_bar_config(disable=A__)

												lowercase							=						1
												lowercase							=						2

												lowercase							=						self.get_dummy_inputs(A__)

												for key in inputs.keys():
																	if key in self.batch_params:
																						lowercase							=						batch_size * [inputs[key]]

												lowercase							=						pipe(**A__   ,num_images_per_prompt=A__)[0]

												assert images.shape[0] == batch_size * num_images_per_prompt







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




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





							def  A__      (				self):
												lowercase							=						load_numpy(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
												    '''/shap_e/test_shap_e_np_out.npy''')
												lowercase							=						ShapEPipeline.from_pretrained('''openai/shap-e''')
												lowercase							=						pipe.to(A__)
												pipe.set_progress_bar_config(disable=A__)

												lowercase							=						torch.Generator(device=A__).manual_seed(0)

												lowercase							=						pipe(
												    '''a shark'''   ,generator=A__   ,guidance_scale=15.0   ,num_inference_steps=6_4   ,frame_size=6_4   ,output_type='''np'''   ,).images[0]

												assert images.shape == (2_0, 6_4, 6_4, 3)

												assert_mean_pixel_difference(A__   ,A__)




