



'''simple docstring'''





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 	lowerCAmelCase_(    SCREAMING_SNAKE_CASE_						,			unittest.TestCase					):
  '''simple docstring'''




  __lowercase							:				str           =				ShapEPipeline
  __lowercase							:				int           =				['''prompt''']
  __lowercase							:				str           =				['''prompt''']
  __lowercase							:				str           =				[
      '''num_images_per_prompt''',
      '''num_inference_steps''',
      '''generator''',
      '''latents''',
      '''guidance_scale''',
      '''frame_size''',
      '''output_type''',
      '''return_dict''',
  ]
  __lowercase							:				Optional[int]           =				False




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Tuple:
      return 32




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Union[str, Any]:
      return 32




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Optional[int]:
      return self.time_input_dim * 4




  @property
  def 							UpperCAmelCase_     (   self				)   ->		List[Any]:
      return 8




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Dict:
      lowerCAmelCase__			:  Tuple											= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)
      return tokenizer




  @property
  def 							UpperCAmelCase_     (   self				)   ->		str:
      torch.manual_seed(0				)
      lowerCAmelCase__			:  Union[str, Any]											= 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=37  ,layer_norm_eps=1E-05  ,num_attention_heads=4  ,num_hidden_layers=5  ,pad_token_id=1  ,vocab_size=1000  ,)
      return CLIPTextModelWithProjection(__UpperCAmelCase				)




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Tuple:
      torch.manual_seed(0				)

      lowerCAmelCase__			:  Optional[Any]											= {
          """num_attention_heads""": 2,
          """attention_head_dim""": 16,
          """embedding_dim""": self.time_input_dim,
          """num_embeddings""": 32,
          """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,
      }

      lowerCAmelCase__			:  int											= PriorTransformer(**__UpperCAmelCase				)
      return model




  @property
  def 							UpperCAmelCase_     (   self				)   ->		Any:
      torch.manual_seed(0				)

      lowerCAmelCase__			:  str											= {
          """param_shapes""": (
              (self.renderer_dim, 93),
              (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""": 12,
          """background""": (
              0.1,
              0.1,
              0.1,
          ),
      }
      lowerCAmelCase__			:  Dict											= ShapERenderer(**__UpperCAmelCase				)
      return model




  def 							UpperCAmelCase_     (   self				)   ->		List[Any]:
      lowerCAmelCase__			:  Union[str, Any]											= self.dummy_prior
      lowerCAmelCase__			:  Any											= self.dummy_text_encoder
      lowerCAmelCase__			:  Union[str, Any]											= self.dummy_tokenizer
      lowerCAmelCase__			:  str											= self.dummy_renderer

      lowerCAmelCase__			:  Dict											= HeunDiscreteScheduler(
          beta_schedule="""exp"""  ,num_train_timesteps=1024  ,prediction_type="""sample"""  ,use_karras_sigmas=__UpperCAmelCase  ,clip_sample=__UpperCAmelCase  ,clip_sample_range=1.0  ,)
      lowerCAmelCase__			:  List[Any]											= {
          """prior""": prior,
          """text_encoder""": text_encoder,
          """tokenizer""": tokenizer,
          """renderer""": renderer,
          """scheduler""": scheduler,
      }

      return components




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase  ,__UpperCAmelCase=0				)   ->		Tuple:
      if str(__UpperCAmelCase				).startswith("""mps"""				):
          lowerCAmelCase__			:  Optional[int]											= torch.manual_seed(__UpperCAmelCase				)
      else:
          lowerCAmelCase__			:  Any											= torch.Generator(device=__UpperCAmelCase				).manual_seed(__UpperCAmelCase				)
      lowerCAmelCase__			:  str											= {
          """prompt""": """horse""",
          """generator""": generator,
          """num_inference_steps""": 1,
          """frame_size""": 32,
          """output_type""": """np""",
      }
      return inputs




  def 							UpperCAmelCase_     (   self				)   ->		Optional[Any]:
      lowerCAmelCase__			:  List[str]											= """cpu"""

      lowerCAmelCase__			:  Tuple											= self.get_dummy_components()

      lowerCAmelCase__			:  int											= self.pipeline_class(**__UpperCAmelCase				)
      lowerCAmelCase__			:  Dict											= pipe.to(__UpperCAmelCase				)

      pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

      lowerCAmelCase__			:  int											= pipe(**self.get_dummy_inputs(__UpperCAmelCase				)				)
      lowerCAmelCase__			:  str											= output.images[0]
      lowerCAmelCase__			:  List[str]											= image[0, -3:, -3:, -1]

      assert image.shape == (20, 32, 32, 3)

      lowerCAmelCase__			:  List[str]											= np.array(
          [
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
              0.0_0_0_3_9_2_1_6,
          ]				)

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




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




  def 							UpperCAmelCase_     (   self				)   ->		str:
      lowerCAmelCase__			:  Any											= torch_device == """cpu"""
      lowerCAmelCase__			:  Optional[int]											= True

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






  def 							UpperCAmelCase_     (   self				)   ->		Dict:
      lowerCAmelCase__			:  Any											= self.get_dummy_components()
      lowerCAmelCase__			:  str											= self.pipeline_class(**__UpperCAmelCase				)
      lowerCAmelCase__			:  Optional[int]											= pipe.to(__UpperCAmelCase				)
      pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

      lowerCAmelCase__			:  Optional[Any]											= 1
      lowerCAmelCase__			:  List[Any]											= 2

      lowerCAmelCase__			:  Dict											= self.get_dummy_inputs(__UpperCAmelCase				)

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

      lowerCAmelCase__			:  Tuple											= pipe(**__UpperCAmelCase  ,num_images_per_prompt=__UpperCAmelCase				)[0]

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







@slow
@require_torch_gpu
class 	lowerCAmelCase_(    unittest.TestCase					):
  '''simple docstring'''




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






  def 							UpperCAmelCase_     (   self				)   ->		List[Any]:
      lowerCAmelCase__			:  str											= load_numpy(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
          """/shap_e/test_shap_e_np_out.npy"""				)
      lowerCAmelCase__			:  Optional[Any]											= ShapEPipeline.from_pretrained("""openai/shap-e"""				)
      lowerCAmelCase__			:  Union[str, Any]											= pipe.to(__UpperCAmelCase				)
      pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

      lowerCAmelCase__			:  Any											= torch.Generator(device=__UpperCAmelCase				).manual_seed(0				)

      lowerCAmelCase__			:  str											= pipe(
          """a shark"""  ,generator=__UpperCAmelCase  ,guidance_scale=1_5.0  ,num_inference_steps=64  ,frame_size=64  ,output_type="""np"""  ,).images[0]

      assert images.shape == (20, 64, 64, 3)

      assert_mean_pixel_difference(__UpperCAmelCase  ,__UpperCAmelCase				)







'''simple docstring'''





from typing import Any






class 	lowerCAmelCase_:
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase				)   ->		Any:
      lowerCAmelCase__			:  Optional[Any]											= data
      lowerCAmelCase__			:  str											= None






  def __repr__(   self				)   ->		str:
      return F"""Node({self.data})"""







class 	lowerCAmelCase_:
  '''simple docstring'''




  def __init__(   self				)   ->		List[Any]:
      lowerCAmelCase__			:  List[str]											= None




  def __iter__(   self				)   ->		Any:
      lowerCAmelCase__			:  int											= self.head
      while node:
          yield node.data
          lowerCAmelCase__			:  Optional[Any]											= node.next




  def __len__(   self				)   ->		int:
      return sum(1 for _ in self				)




  def __repr__(   self				)   ->		str:
      return "->".join([str(__UpperCAmelCase				) for item in self]				)




  def __getitem__(   self  ,__UpperCAmelCase				)   ->		Any:
      if not 0 <= index < len(self				):
          raise ValueError("""list index out of range."""				)
      for i, node in enumerate(self				):
          if i == index:
              return node
      return None




  def __setitem__(   self  ,__UpperCAmelCase  ,__UpperCAmelCase				)   ->		None:
      if not 0 <= index < len(self				):
          raise ValueError("""list index out of range."""				)
      lowerCAmelCase__			:  List[Any]											= self.head
      for _ in range(__UpperCAmelCase				):
          lowerCAmelCase__			:  List[str]											= current.next
      lowerCAmelCase__			:  Dict											= data




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		None:
      self.insert_nth(len(self				)  ,__UpperCAmelCase				)




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		None:
      self.insert_nth(0  ,__UpperCAmelCase				)




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase  ,__UpperCAmelCase				)   ->		None:
      if not 0 <= index <= len(self				):
          raise IndexError("""list index out of range"""				)
      lowerCAmelCase__			:  str											= Node(__UpperCAmelCase				)
      if self.head is None:
          lowerCAmelCase__			:  List[Any]											= new_node
      elif index == 0:
          lowerCAmelCase__			:  Dict											= self.head  # link new_node to head
          lowerCAmelCase__			:  int											= new_node
      else:
          lowerCAmelCase__			:  Any											= self.head
          for _ in range(index - 1				):
              lowerCAmelCase__			:  Tuple											= temp.next
          lowerCAmelCase__			:  str											= temp.next
          lowerCAmelCase__			:  Optional[int]											= new_node




  def 							UpperCAmelCase_     (   self				)   ->		None:  # print every node data
      print(self				)




  def 							UpperCAmelCase_     (   self				)   ->		Any:
      return self.delete_nth(0				)




  def 							UpperCAmelCase_     (   self				)   ->		Any:  # delete from tail
      return self.delete_nth(len(self				) - 1				)




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase = 0				)   ->		Any:
      if not 0 <= index <= len(self				) - 1:  # test if index is valid
          raise IndexError("""List index out of range."""				)
      lowerCAmelCase__			:  List[Any]											= self.head  # default first node
      if index == 0:
          lowerCAmelCase__			:  str											= self.head.next
      else:
          lowerCAmelCase__			:  int											= self.head
          for _ in range(index - 1				):
              lowerCAmelCase__			:  Union[str, Any]											= temp.next
          lowerCAmelCase__			:  Optional[Any]											= temp.next
          lowerCAmelCase__			:  Any											= temp.next.next
      return delete_node.data




  def 							UpperCAmelCase_     (   self				)   ->		bool:
      return self.head is None






  def 							UpperCAmelCase_     (   self				)   ->		None:
      lowerCAmelCase__			:  Optional[int]											= None
      lowerCAmelCase__			:  str											= self.head

      while current:
          # Store the current node's next node.
          lowerCAmelCase__			:  Optional[Any]											= current.next
          # Make the current node's next point backwards
          lowerCAmelCase__			:  Optional[int]											= prev
          # Make the previous node be the current node
          lowerCAmelCase__			:  Optional[Any]											= current
          # Make the current node the next node (to progress iteration)
          lowerCAmelCase__			:  Optional[int]											= next_node
      # Return prev in order to put the head at the end
      lowerCAmelCase__			:  List[str]											= prev







def        _SCREAMING_SNAKE_CASE  (	):



    """simple docstring"""





    lowerCAmelCase__			:  Dict											= LinkedList()
    assert linked_list.is_empty() is True
    assert str(UpperCamelCase      ) == ""

    try:
        linked_list.delete_head()
        raise AssertionError  # This should not happen.
    except IndexError:
        assert True  # This should happen.

    try:
        linked_list.delete_tail()
        raise AssertionError  # This should not happen.
    except IndexError:
        assert True  # This should happen.

    for i in range(10      ):
        assert len(UpperCamelCase      ) == i
        linked_list.insert_nth(UpperCamelCase							,   i + 1      )
    assert str(UpperCamelCase      ) == "->".join(str(UpperCamelCase      ) for i in range(1							,   11      )      )

    linked_list.insert_head(0      )
    linked_list.insert_tail(11      )
    assert str(UpperCamelCase      ) == "->".join(str(UpperCamelCase      ) for i in range(0							,   12      )      )

    assert linked_list.delete_head() == 0
    assert linked_list.delete_nth(9      ) == 10
    assert linked_list.delete_tail() == 11
    assert len(UpperCamelCase      ) == 9
    assert str(UpperCamelCase      ) == "->".join(str(UpperCamelCase      ) for i in range(1							,   10      )      )

    assert all(linked_list[i] == i + 1 for i in range(0							,   9      )      ) is True

    for i in range(0							,   9      ):
        lowerCAmelCase__			:  str											= -i
    assert all(linked_list[i] == -i for i in range(0							,   9      )      ) is True

    linked_list.reverse()
    assert str(UpperCamelCase      ) == "->".join(str(UpperCamelCase      ) for i in range(-8							,   1      )      )
def        _SCREAMING_SNAKE_CASE  (	):



    """simple docstring"""





    lowerCAmelCase__			:  Any											= [
        -9,
        100,
        Node(77345112      ),
        """dlrow olleH""",
        7,
        5555,
        0,
        -192.5_5555,
        """Hello, world!""",
        77.9,
        Node(10      ),
        None,
        None,
        12.20,
    ]
    lowerCAmelCase__			:  List[Any]											= LinkedList()

    for i in test_input:
        linked_list.insert_tail(UpperCamelCase      )

    # Check if it's empty or not
    assert linked_list.is_empty() is False
    assert (
        str(UpperCamelCase      ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
        "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
    )

    # Delete the head
    lowerCAmelCase__			:  List[str]											= linked_list.delete_head()
    assert result == -9
    assert (
        str(UpperCamelCase      ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
        "Hello, world!->77.9->Node(10)->None->None->12.2"
    )

    # Delete the tail
    lowerCAmelCase__			:  Union[str, Any]											= linked_list.delete_tail()
    assert result == 12.2
    assert (
        str(UpperCamelCase      ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
        "Hello, world!->77.9->Node(10)->None->None"
    )

    # Delete a node in specific location in linked list
    lowerCAmelCase__			:  str											= linked_list.delete_nth(10      )
    assert result is None
    assert (
        str(UpperCamelCase      ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
        "Hello, world!->77.9->Node(10)->None"
    )

    # Add a Node instance to its head
    linked_list.insert_head(Node("""Hello again, world!"""      )      )
    assert (
        str(UpperCamelCase      )
        == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
        "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
    )

    # Add None to its tail
    linked_list.insert_tail(UpperCamelCase      )
    assert (
        str(UpperCamelCase      )
        == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
        "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
    )

    # Reverse the linked list
    linked_list.reverse()
    assert (
        str(UpperCamelCase      )
        == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
        "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
    )
def        _SCREAMING_SNAKE_CASE  (	):



    """simple docstring"""





    from doctest import testmod

    testmod()

    lowerCAmelCase__			:  str											= LinkedList()
    linked_list.insert_head(input("""Inserting 1st at head """      ).strip()      )
    linked_list.insert_head(input("""Inserting 2nd at head """      ).strip()      )
    print("""\nPrint list:"""      )
    linked_list.print_list()
    linked_list.insert_tail(input("""\nInserting 1st at tail """      ).strip()      )
    linked_list.insert_tail(input("""Inserting 2nd at tail """      ).strip()      )
    print("""\nPrint list:"""      )
    linked_list.print_list()
    print("""\nDelete head"""      )
    linked_list.delete_head()
    print("""Delete tail"""      )
    linked_list.delete_tail()
    print("""\nPrint list:"""      )
    linked_list.print_list()
    print("""\nReverse linked list"""      )
    linked_list.reverse()
    print("""\nPrint list:"""      )
    linked_list.print_list()
    print("""\nString representation of linked list:"""      )
    print(UpperCamelCase      )
    print("""\nReading/changing Node data using indexing:"""      )
    print(f"""Element at Position 1: {linked_list[1]}"""      )
    lowerCAmelCase__			:  Dict											= input("""Enter New Value: """      ).strip()
    print("""New list:"""      )
    print(UpperCamelCase      )
    print(f"""length of linked_list is : {len(UpperCamelCase      )}"""      )


if __name__ == "__main__":
 main()


