





from collections.abc import Iterable
from typing import Any




class 			__UpperCamelCase    :





     def __init__(     self				,							_UpperCamelCase = None					):
        _UpperCAmelCase           =   value
        _UpperCAmelCase           =   None  # Added in order to delete a node easier
        _UpperCAmelCase           =   None
        _UpperCAmelCase           =   None





     def __repr__(     self					):
        from pprint import pformat

        if self.left is None and self.right is None:
           return str(self.value					)
        return pformat({f'''{self.value}''': (self.left, self.right)}				,							indent=1					)




class 			__UpperCamelCase    :





     def __init__(     self				,							_UpperCamelCase = None					):
        _UpperCAmelCase           =   root





     def __str__(     self					):
        return str(self.root					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase					):
        if new_children is not None:  # reset its kids
           _UpperCAmelCase           =   node.parent
        if node.parent is not None:  # reset its parent
           if self.is_right(_UpperCamelCase					):  # If it is the right children
              _UpperCAmelCase           =   new_children
           else:
              _UpperCAmelCase           =   new_children
        else:
           _UpperCAmelCase           =   new_children





     def 		UpperCamelCase(     self				,							_UpperCamelCase					):
        if node.parent and node.parent.right:
           return node == node.parent.right
        return False





     def 		UpperCamelCase(     self					):
        return self.root is None





     def 		UpperCamelCase(     self				,							_UpperCamelCase					):
        _UpperCAmelCase           =   Node(_UpperCamelCase					)  # create a new Node
        if self.empty():  # if Tree is empty
           _UpperCAmelCase           =   new_node  # set its root
        else:  # Tree is not empty
           _UpperCAmelCase           =   self.root  # from root
           if parent_node is None:
              return
           while True:  # While we don't get to a leaf
              if value < parent_node.value:  # We go left
                 if parent_node.left is None:
                    _UpperCAmelCase           =   new_node  # We insert the new node in a leaf
                    break
                 else:
                    _UpperCAmelCase           =   parent_node.left
              else:
                 if parent_node.right is None:
                    _UpperCAmelCase           =   new_node
                    break
                 else:
                    _UpperCAmelCase           =   parent_node.right
           _UpperCAmelCase           =   parent_node





     def 		UpperCamelCase(     self				,							*_UpperCamelCase					):
        for value in values:
           self.__insert(_UpperCamelCase					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase					):
        if self.empty():
           raise IndexError('''Warning: Tree is empty! please use another.'''					)
        else:
           _UpperCAmelCase           =   self.root
           # use lazy evaluation here to avoid NoneType Attribute error
           while node is not None and node.value is not value:
              _UpperCAmelCase           =   node.left if value < node.value else node.right
           return node





     def 		UpperCamelCase(     self				,							_UpperCamelCase = None					):
        if node is None:
           if self.root is None:
              return None
           _UpperCAmelCase           =   self.root

        if not self.empty():
           while node.right is not None:
              _UpperCAmelCase           =   node.right
        return node





     def 		UpperCamelCase(     self				,							_UpperCamelCase = None					):
        if node is None:
           _UpperCAmelCase           =   self.root
        if self.root is None:
           return None
        if not self.empty():
           _UpperCAmelCase           =   self.root
           while node.left is not None:
              _UpperCAmelCase           =   node.left
        return node





     def 		UpperCamelCase(     self				,							_UpperCamelCase					):
        _UpperCAmelCase           =   self.search(_UpperCamelCase					)  # Look for the node with that label
        if node is not None:
           if node.left is None and node.right is None:  # If it has no children
              self.__reassign_nodes(_UpperCamelCase				,							_UpperCamelCase					)
           elif node.left is None:  # Has only right children
              self.__reassign_nodes(_UpperCamelCase				,							node.right					)
           elif node.right is None:  # Has only left children
              self.__reassign_nodes(_UpperCamelCase				,							node.left					)
           else:
              _UpperCAmelCase           =   self.get_max(
                  node.left					)  # Gets the max value of the left branch
              self.remove(tmp_node.value					)  # type: ignore
              _UpperCAmelCase           =   (
                  tmp_node.value  # type: ignore
              )  # Assigns the value to the node to delete and keep tree structure





     def 		UpperCamelCase(     self				,							_UpperCamelCase					):
        if node is not None:
           yield node  # Preorder Traversal
           yield from self.preorder_traverse(node.left					)
           yield from self.preorder_traverse(node.right					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase=None					):
        if traversal_function is None:
           return self.preorder_traverse(self.root					)
        else:
           return traversal_function(self.root					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase					):
        if node:
           self.inorder(_UpperCamelCase				,							node.left					)
           arr.append(node.value					)
           self.inorder(_UpperCamelCase				,							node.right					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   []
        self.inorder(_UpperCamelCase				,							_UpperCamelCase					)  # append all values to list using inorder traversal
        return arr[k - 1]




def      A__       (    SCREAMING_SNAKE_CASE_   :      Node | None						)  ->  list[Node]:






   """simple docstring"""







   _UpperCAmelCase           =   []
   if curr_node is not None:
      _UpperCAmelCase           =   postorder(curr_node.left						) + postorder(curr_node.right						) + [curr_node]
   return node_list
def      A__       (    )  ->  None:






   """simple docstring"""







   _UpperCAmelCase           =   (8, 3, 6, 1, 10, 14, 13, 4, 7)
   _UpperCAmelCase           =   BinarySearchTree()
   for i in testlist:
      t.insert(SCREAMING_SNAKE_CASE_						)

   # Prints all the elements of the list in order traversal
   print(SCREAMING_SNAKE_CASE_						)

   if t.search(6						) is not None:
      print('''The value 6 exists'''						)
   else:
      print('''The value 6 doesn\'t exist'''						)

   if t.search(-1						) is not None:
      print('''The value -1 exists'''						)
   else:
      print('''The value -1 doesn\'t exist'''						)

   if not t.empty():
      print('''Max Value: '''				,	t.get_max().value						)  # type: ignore
      print('''Min Value: '''				,	t.get_min().value						)  # type: ignore

   for i in testlist:
      t.remove(SCREAMING_SNAKE_CASE_						)
      print(SCREAMING_SNAKE_CASE_						)


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)






import gc
import unittest

import numpy as np
import torch

from diffusers import DanceDiffusionPipeline, IPNDMScheduler, UNetaDModel
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS, UNCONDITIONAL_AUDIO_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()




class 			__UpperCamelCase    (							A__	, unittest.TestCase    ):
     __A	:  Any							  =   DanceDiffusionPipeline
     __A	:  Any							  =   UNCONDITIONAL_AUDIO_GENERATION_PARAMS
     __A	:  Tuple							  =   PipelineTesterMixin.required_optional_params - {
         """callback""",
         """latents""",
         """callback_steps""",
         """output_type""",
         """num_images_per_prompt""",
     }
     __A	:  Tuple							  =   UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS
     __A	:  List[str]							  =   False
     __A	:  str							  =   False





     def 		UpperCamelCase(     self					):
        torch.manual_seed(0					)
        _UpperCAmelCase           =   UNetaDModel(
            block_out_channels=(32, 32, 64)				,							extra_in_channels=16				,							sample_size=512				,							sample_rate=16000				,							in_channels=2				,							out_channels=2				,							flip_sin_to_cos=_UpperCamelCase				,							use_timestep_embedding=_UpperCamelCase				,							time_embedding_type='''fourier'''				,							mid_block_type='''UNetMidBlock1D'''				,							down_block_types=('''DownBlock1DNoSkip''', '''DownBlock1D''', '''AttnDownBlock1D''')				,							up_block_types=('''AttnUpBlock1D''', '''UpBlock1D''', '''UpBlock1DNoSkip''')				,							)
        _UpperCAmelCase           =   IPNDMScheduler()

        _UpperCAmelCase           =   {
            '''unet''': unet,
            '''scheduler''': scheduler,
        }
        return components





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase=0					):
        if str(_UpperCamelCase					).startswith('''mps'''					):
           _UpperCAmelCase           =   torch.manual_seed(_UpperCamelCase					)
        else:
           _UpperCAmelCase           =   torch.Generator(device=_UpperCamelCase					).manual_seed(_UpperCamelCase					)
        _UpperCAmelCase           =   {
            '''batch_size''': 1,
            '''generator''': generator,
            '''num_inference_steps''': 4,
        }
        return inputs





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   '''cpu'''  # ensure determinism for the device-dependent torch.Generator
        _UpperCAmelCase           =   self.get_dummy_components()
        _UpperCAmelCase           =   DanceDiffusionPipeline(**_UpperCamelCase					)
        _UpperCAmelCase           =   pipe.to(_UpperCamelCase					)
        pipe.set_progress_bar_config(disable=_UpperCamelCase					)

        _UpperCAmelCase           =   self.get_dummy_inputs(_UpperCamelCase					)
        _UpperCAmelCase           =   pipe(**_UpperCamelCase					)
        _UpperCAmelCase           =   output.audios

        _UpperCAmelCase           =   audio[0, -3:, -3:]

        assert audio.shape == (1, 2, components["unet"].sample_size)
        _UpperCAmelCase           =   np.array([-0.7265, 1.0000, -0.8388, 0.1175, 0.9498, -1.0000]					)
        assert np.abs(audio_slice.flatten() - expected_slice					).max() < 1e-2





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_save_load_local()





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3					)





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_save_load_optional_components()





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_attention_slicing_forward_pass()





     def 		UpperCamelCase(     self					):
        super().test_inference_batch_single_identical(expected_max_diff=3e-3					)




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





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





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   torch_device

        _UpperCAmelCase           =   DanceDiffusionPipeline.from_pretrained('''harmonai/maestro-150k'''					)
        _UpperCAmelCase           =   pipe.to(_UpperCamelCase					)
        pipe.set_progress_bar_config(disable=_UpperCamelCase					)

        _UpperCAmelCase           =   torch.manual_seed(0					)
        _UpperCAmelCase           =   pipe(generator=_UpperCamelCase				,							num_inference_steps=100				,							audio_length_in_s=4.096					)
        _UpperCAmelCase           =   output.audios

        _UpperCAmelCase           =   audio[0, -3:, -3:]

        assert audio.shape == (1, 2, pipe.unet.sample_size)
        _UpperCAmelCase           =   np.array([-0.0192, -0.0231, -0.0318, -0.0059, 0.0002, -0.0020]					)

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





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   torch_device

        _UpperCAmelCase           =   DanceDiffusionPipeline.from_pretrained('''harmonai/maestro-150k'''				,							torch_dtype=torch.floataa					)
        _UpperCAmelCase           =   pipe.to(_UpperCamelCase					)
        pipe.set_progress_bar_config(disable=_UpperCamelCase					)

        _UpperCAmelCase           =   torch.manual_seed(0					)
        _UpperCAmelCase           =   pipe(generator=_UpperCamelCase				,							num_inference_steps=100				,							audio_length_in_s=4.096					)
        _UpperCAmelCase           =   output.audios

        _UpperCAmelCase           =   audio[0, -3:, -3:]

        assert audio.shape == (1, 2, pipe.unet.sample_size)
        _UpperCAmelCase           =   np.array([-0.0367, -0.0488, -0.0771, -0.0525, -0.0444, -0.0341]					)

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