


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 lowerCAmelCase_		(				A_      ,		unittest.TestCase ):

	'''simple docstring'''

	__snake_case				=						DanceDiffusionPipeline
	__snake_case				=						UNCONDITIONAL_AUDIO_GENERATION_PARAMS
	__snake_case				=						PipelineTesterMixin.required_optional_params - {
	    '''callback''',
	    '''latents''',
	    '''callback_steps''',
	    '''output_type''',
	    '''num_images_per_prompt''',
	}
	__snake_case				=						UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS
	__snake_case				=						False
	__snake_case				=						False



	def 		UpperCamelCase__  (			self      ):
							torch.manual_seed(0      )
							snake_case_ =   UNetaDModel(
							    block_out_channels=(32, 32, 64)	,   extra_in_channels=16	,   sample_size=5_12	,   sample_rate=1_60_00	,   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''')	,   )
							snake_case_ =   IPNDMScheduler()

							snake_case_ =   {
							    """unet""": unet,
							    """scheduler""": scheduler,
							}
							return components



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



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

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

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

							assert audio.shape == (1, 2, components["unet"].sample_size)
							snake_case_ =   np.array([-0.7_265, 1.0_000, -0.8_388, 0.1_175, 0.9_498, -1.0_000]      )
							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 lowerCAmelCase_		(				unittest.TestCase ):

	'''simple docstring'''

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



	def 		UpperCamelCase__  (			self      ):
							snake_case_ =   torch_device

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

							snake_case_ =   torch.manual_seed(0      )
							snake_case_ =   pipe(generator=_UpperCAmelCase	,   num_inference_steps=1_00	,   audio_length_in_s=4.096      )
							snake_case_ =   output.audios

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

							assert audio.shape == (1, 2, pipe.unet.sample_size)
							snake_case_ =   np.array([-0.0_192, -0.0_231, -0.0_318, -0.0_059, 0.0_002, -0.0_020]      )

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





	def 		UpperCamelCase__  (			self      ):
							snake_case_ =   torch_device

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

							snake_case_ =   torch.manual_seed(0      )
							snake_case_ =   pipe(generator=_UpperCAmelCase	,   num_inference_steps=1_00	,   audio_length_in_s=4.096      )
							snake_case_ =   output.audios

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

							assert audio.shape == (1, 2, pipe.unet.sample_size)
							snake_case_ =   np.array([-0.0_367, -0.0_488, -0.0_771, -0.0_525, -0.0_444, -0.0_341]      )

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



from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

UpperCAmelCase    =					{"""UserAgent""": UserAgent().random}






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      )->						dict:




      """simple docstring"""

      snake_case_ =   script.contents[0]
      snake_case_ =   json.loads(data[data.find('''{"config"'''      ) : -1]      )
      return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]







class lowerCAmelCase_		:

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase      ):
       snake_case_ =   F'''https://www.instagram.com/{username}/'''
       snake_case_ =   self.get_json()



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   requests.get(self.url	,   headers=_UpperCAmelCase      ).text
       snake_case_ =   BeautifulSoup(_UpperCAmelCase	,   '''html.parser'''      ).find_all('''script'''      )
       try:
             return extract_user_profile(scripts[4]      )
       except (json.decoder.JSONDecodeError, KeyError):
             return extract_user_profile(scripts[3]      )



 def __repr__(			self      ):
       return F'''{self.__class__.__name__}(\'{self.username}\')'''



 def __str__(			self      ):
       return F'''{self.fullname} ({self.username}) is {self.biography}'''



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["username"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["full_name"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["biography"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["business_email"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["external_url"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["edge_followed_by"]["count"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["edge_follow"]["count"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["edge_owner_to_timeline_media"]["count"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["profile_pic_url_hd"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["is_verified"]





 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["is_private"]






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE = "github"      )->						None:




      """simple docstring"""

      import os

      if os.environ.get('''CI'''      ):
            return  # test failing on GitHub Actions
      snake_case_ =   InstagramUser(SCREAMING_SNAKE_CASE      )
      assert instagram_user.user_data
      assert isinstance(instagram_user.user_data      ,      SCREAMING_SNAKE_CASE      )
      assert instagram_user.username == username
      if username != "github":
            return
      assert instagram_user.fullname == "GitHub"
      assert instagram_user.biography == "Built for developers."
      assert instagram_user.number_of_posts > 150
      assert instagram_user.number_of_followers > 12_0000
      assert instagram_user.number_of_followings > 15
      assert instagram_user.email == "support@github.com"
      assert instagram_user.website == "https://github.com/readme"
      assert instagram_user.profile_picture_url.startswith('''https://instagram.'''      )
      assert instagram_user.is_verified is True
      assert instagram_user.is_private is False


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   UpperCAmelCase    =					InstagramUser("""github""")
   print(instagram_user)
   print(f'''{instagram_user.number_of_posts = }''')
   print(f'''{instagram_user.number_of_followers = }''')
   print(f'''{instagram_user.number_of_followings = }''')
   print(f'''{instagram_user.email = }''')
   print(f'''{instagram_user.website = }''')
   print(f'''{instagram_user.profile_picture_url = }''')
   print(f'''{instagram_user.is_verified = }''')
   print(f'''{instagram_user.is_private = }''')